xxx_rename 0.0.1

data/lib/xxx_rename/filename_generator.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module XxxRename
+  class FilenameGenerationError < StandardError
+    attr_reader :extra_tokens
+
+    def initialize(extra_tokens)
+      @extra_tokens = extra_tokens
+      super(message)
+    end
+
+    def message
+      "Format contains token(s) #{@extra_tokens.join(", ")}, but site client returned no values for these arguments."
+    end
+  end
+
+  class InvalidFormatError < StandardError
+    def initialize(extra_tokens: [], contains_extension: nil)
+      @extra_tokens = extra_tokens
+      @contains_extension = contains_extension
+      super(make_message)
+    end
+
+    def make_message
+      if @extra_tokens.length.positive?
+        "invalid token(s) #{@extra_tokens.join(", ")}"
+      elsif @contains_extension
+        "format should not contain extension but found #{@contains_extension}"
+      else
+        raise Errors::FatalError, "#{self.class.name} expects extra_tokens or contains_extension but received neither"
+      end
+    end
+  end
+
+  class FilenameGenerator
+    VALID_TOKENS = %w[%female_actors %male_actors %actors %collection %collection_tag %title %id %yyyy_mm_dd %dd %mm %yyyy].freeze
+    VALID_PREFIX_TOKENS = %w[%female_actors_prefix %male_actors_prefix %actors_prefix %title_prefix %id_prefix].freeze
+
+    VALID_INPUT_TOKENS = %w[%title %collection %collection_op %collection_tag_1 %collection_tag_2 %collection_tag_3
+                            %female_actors %male_actors %male_actors_op %actors
+                            %id %id_op
+                            %ignore_1_word %ignore_2_words %ignore_2_words %ignore_3_words %ignore_4_words
+                            %ignore_5_words %ignore_6_words %ignore_7_words %ignore_all
+                            %yyyy_mm_dd %dd %mm %yyyy %yy].freeze
+
+    class << self
+      #
+      # Helper method for ConfigContract
+      # Validates the global.output_format and
+      # site.{site}.output_format attributes
+      #
+      # @param [String] format
+      # @return [Boolean]
+      # @raise [InvalidFormatError] if string contains invalid tokens
+      def validate_format!(format)
+        tokens_in_format = format.scan(/%\w+/)
+        invalid_tokens = tokens_in_format - VALID_TOKENS - VALID_PREFIX_TOKENS
+        return true if invalid_tokens.empty?
+
+        raise InvalidFormatError.new(extra_tokens: invalid_tokens)
+      end
+
+      #
+      # Helper method for ConfigContract
+      # Validates the site.{site}.file_source_format attribute
+      #
+      # @param [String] format
+      # @return [Boolean]
+      # @raise [InvalidFormatError] if string contains invalid tokens
+      def validate_input_format!(format)
+        tokens_in_format = format.scan(/%\w+/)
+        invalid_tokens = tokens_in_format - VALID_INPUT_TOKENS - VALID_PREFIX_TOKENS
+        return true if invalid_tokens.empty?
+
+        raise InvalidFormatError.new(extra_tokens: invalid_tokens)
+      end
+
+      def generate(scene_data, format, ext_name, prefix_hash)
+        new.generate_filename(scene_data, format, ext_name, prefix_hash)
+      end
+
+      def generate_with_multi_formats!(scene_data, ext_name, prefix_hash, *formats)
+        extra_tokens = []
+        formats.each do |format|
+          resp = new.generate_filename(scene_data, format, ext_name, prefix_hash)
+          return resp
+        rescue FilenameGenerationError => e
+          extra_tokens.push(*e.extra_tokens)
+          nil
+        end
+        raise FilenameGenerationError, extra_tokens.uniq
+      end
+    end
+
+    # @param [XxxRename::Data::SceneData] scene_data
+    # @param [String] format
+    # @param [String] ext_name
+    # @param [Hash] prefix_hash
+    def generate_filename(scene_data, format, ext_name, prefix_hash)
+      self.class.validate_format!(format) && validate_extension!(format, ext_name)
+
+      all_tokens_in_format = format.scan(/%\w+/)
+      tokens_in_format = all_tokens_in_format.reject { |x| x.end_with?("_prefix") }
+
+      format = sub_tokens(scene_data, tokens_in_format, format)
+      format = sub_prefix_tokens(scene_data, all_tokens_in_format, format, prefix_hash)
+
+      validate_after_replacement!(format)
+
+      "#{format.strip.remove_special_characters}#{ext_name}"
+    end
+
+    private
+
+    def sub_tokens(scene_data, tokens, format)
+      long_name_tokens = %w[%female_actors %male_actors %actors]
+
+      tokens.each do |token|
+        fn = token[1..].to_sym
+        value = scene_data.send(fn)
+        next if value.nil? || !value.to_s.presence
+
+        value = "[#{value}]" if fn == :collection_tag && value !~ /\[\w+\]/
+        next if long_name_tokens.include?(token)
+
+        format = format.gsub(/#{token}\b/, value.to_s)
+      end
+
+      format = safe_append_list(format, "%actors", scene_data.actors)
+      format = safe_append_list(format, "%female_actors", scene_data.female_actors)
+      safe_append_list(format, "%male_actors", scene_data.male_actors)
+    end
+
+    def safe_append_list(str, token, arr, max_len = FileUtilities::MAX_FILENAME_LEN)
+      return str if arr.empty? || !str.include?(token)
+
+      formatted_str = str.gsub(/#{token}\b/, arr.join(", ").to_s)
+      return formatted_str if formatted_str.length < max_len
+
+      safe_append_list(str, token, arr[0...-1], max_len)
+    end
+
+    def sub_prefix_tokens(data, tokens, format, prefix_hash)
+      tokens.each do |token|
+        next unless token.end_with?("_prefix")
+
+        value = data.send(token[1..].gsub("_prefix", "").to_sym)
+        format = if value.nil? || value.empty?
+                   format.gsub(/#{token}\b/, "")
+                 else
+                   format.gsub(/#{token}\b/, prefix_hash[token[1..].to_sym])
+                 end
+      end
+      format
+    end
+
+    def validate_extension!(format, ext_name)
+      raise InvalidFormatError.new(contains_extension: match[:ext]) if format.end_with?(ext_name)
+
+      return unless (match = /.*(?<ext>\w{3,4})$/.match(format)) && Constants::VIDEO_EXTENSIONS.include?(match[:ext])
+
+      raise InvalidFormatError.new(contains_extension: match[:ext])
+    end
+
+    # @param [String] file
+    def validate_after_replacement!(file)
+      tokens_in_format = file.scan(/%\w+/)
+      return if tokens_in_format.empty?
+
+      raise FilenameGenerationError, tokens_in_format
+    end
+  end
+end

data/lib/xxx_rename/integrations/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "xxx_rename/utils"
+require "httparty"
+
+module XxxRename
+  module Integrations
+    class Base
+      include Utils
+      include HTTParty
+
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+        self.class.logger(XxxRename.logger, :debug)
+      end
+    end
+  end
+end

data/lib/xxx_rename/integrations/stash_app.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+require "base64"
+
+require "xxx_rename/errors"
+require "xxx_rename/integrations/base"
+require "xxx_rename/file_utilities"
+
+module XxxRename
+  module Integrations
+    class StashAPIError < StandardError
+      def initialize(errors)
+        @errors = errors
+        super(message)
+      end
+
+      def message
+        msg = "Stash API returned error:\n"
+        @errors.each do |e|
+          s  = "\tMESSAGE #{e["message"]}\n"
+          s += "\tOPERATION #{e["path"]} \n"
+          msg += s
+        end
+        msg
+      end
+    end
+
+    class StashApp < Base
+      include FileUtilities
+
+      GRAPHQL_ENDPOINT = "/graphql"
+
+      def initialize(config)
+        super(config)
+        raise Errors::FatalError, "Stash App requires 'url'. Check your configuration." unless config.stash_app.url.presence
+
+        self.class.base_uri(config.stash_app.url)
+        self.class.headers("Content-Type" => "application/json")
+      end
+
+      def setup_credentials!
+        register_api_key(stash_app_config.api_token) if api_key_provided?
+
+        validate_credentials!
+      end
+
+      def fetch_studio(name)
+        response = handle_response! { self.class.post(GRAPHQL_ENDPOINT, body: find_studio_body(name)) }
+        response.dig("data", "findStudios", "studios")&.select { |x| x["name"].normalize == name.normalize }&.first
+      end
+
+      def fetch_movie(name)
+        response = handle_response! { self.class.post(GRAPHQL_ENDPOINT, body: fetch_movie_body(name)) }
+        response.dig("data", "findMovies", "movies")&.select { |x| x["name"].normalize == name.normalize }&.first
+      end
+
+      def create_movie(scene_data, studio_id, retried = false)
+        return if scene_data.movie.nil?
+
+        response = handle_response! { self.class.post(GRAPHQL_ENDPOINT, body: create_movie_body(scene_data.movie, studio_id)) }
+        raise StashAPIError, response["errors"] if response["errors"]
+
+        response.dig("data", "movieCreate")
+      rescue StashAPIError => e
+        # re-raise if already retried
+        raise e if retried
+
+        # as of current implementation, movie creation fails if the image url is invalid
+        # retry again and don't set the back image. consecutive failures will be raised
+        XxxRename.logger.error "[STASH APP MOVIE CREATION RETRY] without back image"
+        hash = scene_data.to_h.tap do |h|
+          h[:movie] = h[:movie].tap { |m_h| m_h.delete(:back_image) }
+        end
+        new_scene_data = Data::SceneData.new(hash)
+        create_movie(new_scene_data, studio_id, true)
+      end
+
+      def fetch_scene(path)
+        response = handle_response! { self.class.post(GRAPHQL_ENDPOINT, body: fetch_scene_body(path)) }
+        scenes = response.dig("data", "findScenes", "scenes")
+        scenes.length == 1 ? scenes.first : nil
+      end
+
+      def update_scene(scene_id, movie_id)
+        response = handle_response! { self.class.post(GRAPHQL_ENDPOINT, body: update_scene_body(scene_id, movie_id)) }
+        raise StashAPIError, response["errors"] if response["errors"]
+
+        response.dig("data", "sceneUpdate")
+      end
+
+      private
+
+      def update_scene_body(scene_id, movie_id)
+        {
+          operationName: "SceneUpdate",
+          variables: {
+            input: {
+              id: scene_id,
+              movies: [
+                { "movie_id": movie_id, "scene_index": nil }
+              ]
+            }
+          },
+
+          query: <<~GRAPHQL
+            mutation SceneUpdate($input: SceneUpdateInput!) {
+              sceneUpdate(input: $input) {
+                id
+                title
+                files {
+                  path
+                }
+                movies {
+                  movie {
+                    id
+                    name
+                    front_image_path
+                  }
+                  scene_index
+                }
+              }
+            }
+          GRAPHQL
+        }.to_json
+      end
+
+      def fetch_scene_body(path)
+        {
+          operationName: "FindScenes",
+          variables: {
+            filter: {
+              per_page: 2
+            },
+            scene_filter: {
+              path: {
+                modifier: "INCLUDES",
+                value: "\"#{path}\""
+              }
+            }
+          },
+          query: <<~GRAPHQL
+            query FindScenes($filter: FindFilterType, $scene_filter: SceneFilterType, $scene_ids: [Int!]) {
+              findScenes(filter: $filter, scene_filter: $scene_filter, scene_ids: $scene_ids) {
+                scenes {
+                  id
+                  title
+                  files {
+                    path
+                  }
+                  movies {
+                      movie {
+                        id
+                        name
+                        front_image_path
+                      }
+                      scene_index
+                  }
+                }
+              }
+            }
+          GRAPHQL
+        }.to_json
+      end
+
+      def create_movie_body(movie, studio_id)
+        variables = {}.tap do |h|
+          h[:name]        = movie.name
+          h[:date]        = movie.date&.strftime("%Y-%m-%d") if movie.date
+          h[:url]         = movie.url                        if movie.url
+          h[:front_image] = movie.front_image
+          h[:back_image]  = movie.back_image                 if movie.back_image
+          h[:studio_id]   = studio_id                        if studio_id
+          h[:synopsis]    = movie.synopsis                   if movie.synopsis
+        end
+
+        {
+          operationName: "MovieCreate",
+          variables: variables,
+          query: <<~GRAPHQL
+            mutation MovieCreate(
+              $name: String!
+              $aliases: String
+              $duration: Int
+              $date: String
+              $rating: Int
+              $studio_id: ID
+              $director: String
+              $synopsis: String
+              $url: String
+              $front_image: String
+              $back_image: String
+            ) {
+              movieCreate(
+                input: {
+                  name: $name
+                  aliases: $aliases
+                  duration: $duration
+                  date: $date
+                  rating: $rating
+                  studio_id: $studio_id
+                  director: $director
+                  synopsis: $synopsis
+                  url: $url
+                  front_image: $front_image
+                  back_image: $back_image
+                }
+              ) {
+                id
+                name
+                duration
+                date
+                director
+                studio {
+                  id
+                  name
+                }
+                synopsis
+                url
+                front_image_path
+                back_image_path
+              }
+            }
+          GRAPHQL
+        }.to_json
+      end
+
+      def fetch_movie_body(name)
+        {
+          operationName: "FindMovies",
+          variables: {
+            filter: {
+              per_page: 5
+            },
+            movie_filter: {
+              name: {
+                modifier: "EQUALS",
+                value: name
+              }
+            }
+          },
+          query: <<~GRAPHQL
+            query FindMovies($filter: FindFilterType, $movie_filter: MovieFilterType) {
+              findMovies(filter: $filter, movie_filter: $movie_filter) {
+                movies {
+                  id
+                  name
+                  scenes {
+                    id
+                    title
+                    path
+                  }
+                }
+              }
+            }
+          GRAPHQL
+        }.to_json
+      end
+
+      def find_studio_body(name)
+        {
+          operationName: "FindStudios",
+          variables: {
+            filter: {
+              per_page: 5
+            },
+            studio_filter: {
+              name: {
+                modifier: "EQUALS",
+                value: name
+              }
+            }
+          },
+          query: <<~GRAPHQL
+            query FindStudios($filter: FindFilterType, $studio_filter: StudioFilterType) {
+              findStudios(filter: $filter, studio_filter: $studio_filter) {
+                studios {
+                  id
+                  name
+                }
+              }
+            }
+          GRAPHQL
+        }.to_json
+      end
+
+      def register_api_key(api_token)
+        @api_key_set = true
+        self.class.headers "ApiKey" => api_token
+      end
+
+      def api_key_provided?
+        stash_app_config.api_token.to_s.presence.is_a?(String)
+      end
+
+      def validate_credentials!
+        body = {
+          operationName: "Version",
+          query: <<~GRAPHQL
+            query Version {
+              version {
+                version
+              }
+            }
+          GRAPHQL
+        }.to_json
+
+        resp = handle_response! { self.class.post(GRAPHQL_ENDPOINT, body: body) }
+        resp.dig("data", "version", "version")
+      end
+
+      def stash_app_config
+        config.stash_app
+      end
+    end
+  end
+end

data/lib/xxx_rename/log.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module XxxRename
+  class Log
+    attr_accessor :logger
+
+    def initialize(logdev = $stdout, level = "INFO", **opts)
+      @logger = Logger.new(logdev)
+      @logger.level = opts[:verbose] ? "DEBUG" : level
+      # @logger.level = "DEBUG"
+      @logger.formatter = proc do |severity, datetime, _progname, msg|
+        date_format = datetime.strftime("%H:%M:%S")
+        case severity
+        when "INFO"  then "#{"[#{date_format}] [#{severity.ljust(5)}]".to_s.colorize(:blue)} #{msg}\n"
+        when "ERROR" then "#{"[#{date_format}] [#{severity.ljust(5)}]".to_s.colorize(:light_red)} #{msg}\n"
+        when "FATAL" then "#{"[#{date_format}] [#{severity.ljust(5)}]".to_s.colorize(:red)} #{msg}\n"
+        when "WARN"  then "#{"[#{date_format}] [#{severity.ljust(5)}]".to_s.colorize(:yellow)} #{msg}\n"
+        when "DEBUG" then "#{"[#{date_format}] [#{severity.ljust(5)}]".to_s.colorize(:light_magenta)} #{msg}\n"
+        else "[#{date_format}] [#{severity.ljust(5)}] #{msg}\n"
+        end
+      end
+    end
+  end
+end

data/lib/xxx_rename/migration_client.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/try"
+require "yaml/store"
+
+require "xxx_rename/errors"
+require "xxx_rename/data/file_rename_op"
+require "xxx_rename/data/file_rename_op_datastore"
+
+module XxxRename
+  class MigrationClient
+    MIGRATION_FORMAT = /output_(?<version>\d{12})/x.freeze
+
+    attr_reader :config, :version
+
+    # @param [XxxRename::Data::Config] config
+    # @param [String] version
+    def initialize(config, version)
+      @version = version
+      @config = config
+    end
+
+    def version_file!
+      Dir.chdir(output_dir) do
+        all_output_files = Dir["output_*.yml"].sort.reverse!
+        raise Errors::FatalError, "[ERR NO MIGRATION FILES FOUND]" if all_output_files.empty?
+
+        file = match_file!(all_output_files)
+        File.join(Dir.pwd, file)
+      end
+    end
+
+    def datastore
+      @datastore ||= Data::FileRenameOpDatastore.new(store, config.mutex)
+    end
+
+    def apply
+      if datastore.migration_status
+        XxxRename.logger.info "[MIGRATION UP]"
+        return
+      end
+
+      XxxRename.logger.info "[RENAMING #{datastore.length} FILES]"
+      datastore.all.each do |op|
+        process_rename_op(op)
+      rescue SystemCallError => e
+        XxxRename.logger.error "[RENAME FAILURE] #{e.message}"
+        datastore.add_failure(op.key, e.message)
+      end
+    ensure
+      if datastore.failures.empty?
+        datastore.migration_status = 1
+        XxxRename.logger.info "[MIGRATION UP]"
+      end
+    end
+
+    def rollback
+      unless datastore.migration_status
+        XxxRename.logger.info "[MIGRATION DOWN]"
+        return
+      end
+
+      XxxRename.logger.info "[ROLLBACK RENAMING #{datastore.length} FILES]"
+      datastore.all.each do |op|
+        process_reverse_rename_op(op)
+      rescue SystemCallError => e
+        XxxRename.logger.error "[RENAME FAILURE] #{e.message}"
+        datastore.add_failure(op.key, e.message)
+      end
+    ensure
+      if datastore.failures.empty?
+        datastore.migration_status = 0
+        XxxRename.logger.info "[MIGRATION DOWN]"
+      end
+    end
+
+    private
+
+    def match_file!(all_output_files)
+      if version.downcase == "latest"
+        all_output_files.first
+      else
+        matched_file = all_output_files.select do |x|
+          match = x.match(MIGRATION_FORMAT)
+          next if match.nil?
+
+          match[:version] == version
+        end.compact.first
+        raise Errors::FatalError, "[ERR VERSION NOT EXIST] #{version}" if matched_file.nil?
+
+        matched_file
+      end
+    end
+
+    def process_rename_op(rename_op)
+      if rename_op.is_a?(XxxRename::Data::FileRenameOp)
+        rename_op.rename
+        register_new_file(rename_op)
+      else
+        XxxRename.logger.error "[INVALID RENAME OP] #{rename_op}"
+      end
+    end
+
+    def register_new_file(rename_op)
+      scene_data = config.scene_datastore.find_by_key?(rename_op.key)
+      return if scene_data.nil?
+
+      config.scene_datastore.register_file(scene_data,
+                                           File.join(rename_op.directory, rename_op.output_filename),
+                                           old_filename: File.join(rename_op.directory, rename_op.source_filename))
+    end
+
+    def process_reverse_rename_op(rename_op)
+      if rename_op.is_a?(XxxRename::Data::FileRenameOp)
+        rename_op.reverse_rename
+        register_old_filename(rename_op)
+      else
+        XxxRename.logger.error "[INVALID RENAME OP] #{rename_op}"
+      end
+    end
+
+    def register_old_filename(rename_op)
+      scene_data = config.scene_datastore.find_by_key?(rename_op.key)
+      return if scene_data.nil?
+
+      config.scene_datastore.register_file(scene_data,
+                                           File.join(rename_op.directory, rename_op.source_filename),
+                                           old_filename: File.join(rename_op.directory, rename_op.output_filename))
+    end
+
+    def store
+      @store ||= YAML::Store.new(version_file!)
+    end
+
+    def output_dir
+      @output_dir ||= File.join(config.generated_files_dir, "output")
+    end
+  end
+end