xxx_rename 0.0.1

data/lib/xxx_rename/site_clients/naughty_america.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "pathname"
+require "xxx_rename/site_clients/query_generator/naughty_america"
+
+module XxxRename
+  module SiteClients
+    class NaughtyAmerica < Base
+      include HTTParty
+      base_uri "https://www.naughtyamerica.com"
+
+      site_client_name :naughty_america
+      ACTOR_ENDPOINT = "/pornstar"
+
+      def search(filename)
+        resp = SiteClients::QueryGenerator::NaughtyAmerica.generate(filename, source_format)
+        case resp
+        when String
+          search_unprocessed(filename, resp)
+        when SiteClients::QueryGenerator::Base::SearchParameters
+          search_processed(resp)
+        else
+          raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, filename)
+        end
+      end
+
+      def search_processed(scene_data)
+        female_actor = scene_data.female_actors.first || scene_data.actors.first
+        scenes = fetch_scenes(female_actor)
+        scenes.select do |x|
+          x.match_processed?(scene_data)
+        end.first&.to_struct || raise(Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, scene_data.to_s))
+      end
+
+      def search_unprocessed(filename, compressed_scene_title)
+        actor = parent_dir(filename)
+        scenes = fetch_scenes(actor)
+        match = scenes.select { |x| x.match_unprocessed?(compressed_scene_title) }.first&.to_struct
+
+        return match if match
+
+        XxxRename.logger.error "#{actor} - #{compressed_scene_title}"
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_RESULT, compressed_scene_title)
+      end
+
+      # @param [String] actor
+      # @return [Array[NaughtyAmericaScene]]
+      def fetch_scenes(actor, force = false)
+        if force
+          XxxRename.logger.debug "Force fetch scene #{actor}"
+          fetch_scenes_from_api(actor)
+        else
+          fetch_scenes_from_cache(actor) || fetch_scenes_from_api(actor)
+        end
+      end
+
+      def fetch_scenes_from_cache(actor)
+        scene_store.transaction(true) do
+          scene_store[normalized_actor(actor)]
+        end
+      end
+
+      def fetch_scenes_from_api(actor)
+        scenes = process_actor(actor)
+        return if scenes.nil?
+
+        cache_scenes(normalized_actor(actor), scenes)
+      end
+
+      def cache_scenes(actor, scenes)
+        scene_store.transaction do
+          scene_store[actor] = [] unless scene_store[actor]
+          existing_actors = scene_store[actor]
+          diff_scenes = scenes - existing_actors
+          diff_scenes.each do |scene|
+            XxxRename.logger.debug "Adding #{scene.title} to cache"
+            scene_store[actor] << scene
+          end
+        end
+      end
+
+      def normalized_actor(actor)
+        actor.normalize
+      end
+
+      def process_actor(actor)
+        actor_all_scenes = []
+        (1..5).to_a.each { |page| actor_all_scenes.concat(fetch_actors_page(actor, page: page)) }
+      rescue Errors::NoMatchError => e
+        case e.code
+        when NoMatchError::ERR_NO_RESULT
+          XxxRename.logger.info "Naughty America does not have an actor named #{actor}"
+        when NoMatchError::ERR_NW_REDIRECT
+          XxxRename.logger.debug "Page #{e.data} exceeded maximum available pages"
+        end
+        actor_all_scenes
+      end
+
+      def fetch_actors_page(actor, page:)
+        doc = fetch_actor_page!(actor, page: page)
+        scenes = doc.css(".contain-block").css(".alt-bg").css(".scene-item")
+        scenes.map do |scene|
+          next if vr?(scene)
+
+          NaughtyAmericaScene.new(
+            collection: collection(scene),
+            actors: actors(scene),
+            date_released: date_released(scene),
+            remastered: remastered?(scene),
+            title: title(scene),
+            id: id(scene)
+          )
+        end.compact
+      end
+
+      def title(scene)
+        scene_path(scene).split("-")[..-2].join(" ").humanize
+      end
+
+      def id(scene)
+        id = scene_path(scene).split("-").last
+        Integer(id) ? id.to_s : ""
+      end
+
+      def scene_path(scene)
+        URI(scene.css("a").first["href"]).path.split("/").last
+      end
+
+      def remastered?(scene)
+        scene.css("a").any? { |x| x.text.strip.upcase == "REMASTERED HD" }
+      end
+
+      def vr?(scene)
+        scene.css("a").any? { |x| x.text.strip == "VR" }
+      end
+
+      def collection(scene)
+        scene.css(".site-title").text.strip
+      end
+
+      def actors(scene)
+        scene.css(".contain-actors a").map { |x| x.text.strip }
+      end
+
+      def date_released(scene)
+        Time.strptime(scene.css(".entry-date").text.strip, "%b %d, %Y")
+      end
+
+      def parent_dir(filename)
+        path = Pathname.new(File.join(Dir.pwd, filename))
+        path.dirname.each_filename.to_a.last
+      end
+
+      def fetch_actor_page!(actor, page:)
+        actor_name_normalised = actor.downcase.gsub("\s", "-")
+        endpoint = File.join(ACTOR_ENDPOINT, actor_name_normalised)
+        query = { related_page: page }
+        XxxRename.logger.debug "API path: #{endpoint}, query: #{query}"
+        resp = self.class.get(endpoint, query: query, follow_redirects: false)
+        case resp.code
+        when 200 then Nokogiri::HTML(resp.body)
+        when 301 then raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NW_REDIRECT, page)
+        when 404 then raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_RESULT, actor_name_normalised)
+        when 503 then raise SiteClients::Errors::SiteClientUnavailableError, self.class.base_uri
+        else raise "Something went wrong #{resp.code}"
+        end
+      end
+
+      def scene_store
+        @scene_store ||= Data::NaughtyAmericaDatabase.new(site_config.database).store
+      end
+
+      class NaughtyAmericaScene
+        attr_reader :actors, :collection, :date_released, :remastered, :title, :id
+
+        COLLECTION_ABBRS = {
+          "americandaydreams" => "add",
+          "diaryofananny" => "don",
+          "housewife1on1" => "h1on1",
+          "ihaveawife" => "ihw",
+          "fasttimes" => "ftna",
+          "lasluts" => "las",
+          "latinadultery" => "lad",
+          "momsmoney" => "momo",
+          "mrscreampie" => "namcp",
+          "mywifeismypornstar" => "mwmp",
+          "naughtyamerica" => "nam",
+          "naughtyathletics" => "nath",
+          "naughtybookworms" => "nbw",
+          "naughtyweddings" => "naw",
+          "neighboraffair" => "naf",
+          "seducedbycougar" => "sbc",
+          "watchyourmom" => "natngf",
+          "dirtywivesclub" => "nadwc"
+        }.freeze
+
+        ACTOR_ABBRS = {
+          "mrpete" => %w[mrpete pete],
+          "ryandriller" => %w[ryandriller ryan driller]
+        }.freeze
+
+        def initialize(collection:, actors:, date_released:, remastered:, title:, id:)
+          @collection = collection
+          @actors = actors
+          @date_released = date_released
+          @title = title
+          @id = id
+          @remastered = remastered
+        end
+
+        def condensed_collection
+          col = COLLECTION_ABBRS[collection.normalize]
+          return col if col
+
+          collection.split(" ").map { |x| x[0, 1] }.join("").downcase
+        end
+
+        def female_actors
+          actors.select { |x| ActorsHelper.instance.female? x }
+        end
+
+        def male_actors
+          actors.select { |x| ActorsHelper.instance.male? x }
+        end
+
+        def condensed_actor(actor)
+          act = ACTOR_ABBRS[actor.normalize]
+          return act if act
+
+          [actor.downcase.normalize, actor.split(" ").first&.downcase]
+        end
+
+        def remastered?
+          remastered
+        end
+
+        def match_unprocessed?(condensed_title)
+          dup = condensed_title.dup
+          dup.slice!(condensed_collection)
+          dup.slice!("rem") if remastered?
+          actors.each { |x| condensed_actor(x).each { |y| dup.slice!(y) } }
+          dup == ""
+        end
+
+        def match_processed?(scene_data)
+          arity = []
+          arity << (scene_data.actors - actors == [])
+          arity << (scene_data.collection.normalize == collection.normalize)
+          arity << (scene_data.title.normalize == title.normalize) unless scene_data.title.nil? || scene_data.title.empty?
+          arity << (scene_data.id == id) unless scene_data.id.nil? || scene_data.id.empty?
+          arity.none?(false)
+        end
+
+        def to_struct
+          actors.each { |x| ActorsHelper.instance.auto_fetch x }
+
+          Data::SceneData.new(
+            female_actors: female_actors,
+            male_actors: male_actors,
+            actors: actors,
+            title: title,
+            collection: collection,
+            collection_tag: "NA",
+            id: id,
+            date_released: date_released
+          )
+        end
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/nfbusty.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "xxx_rename"
+
+module XxxRename
+  module SiteClients
+    class Nfbusty < Base
+      include HTTParty
+
+      base_uri "https://nfbusty.com"
+      site_client_name :nf_busty
+
+      SCENE_TITLE_REGEX = /^(?<scene_title>^.*)\s-\sS\d*:E\d*$/x.freeze
+      PAGE_COUNTER_REGEX = /(?<first>\d+)\sof\s(?<last>\d+)/x.freeze
+      FILE_REGEX = /^nfbusty_(?<scene_title>\w*)_\d+\.\w+$/x.freeze
+
+      def search(filename)
+        if response.empty?
+          XxxRename.logger.info "NFBusty extracts all the scenes before matching. This process may take some time.".colorize(:red)
+          fetch_all_scenes
+        end
+
+        scene_match = filename.match(FILE_REGEX)
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, filename) if scene_match.nil?
+
+        title = scene_match[:scene_title].normalize
+        @response[title] || raise(Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_RESULT, filename))
+      end
+
+      private
+
+      def response
+        @response ||= {}
+      end
+
+      def last_page?(doc)
+        page_text = doc.css(".dropdown-toggle").text.strip
+        match = page_text.match PAGE_COUNTER_REGEX
+        raise "Unable to parse page counter" if match.nil?
+
+        true if match[:first] == match[:last]
+      end
+
+      def fetch_all_scenes(page = 0)
+        XxxRename.logger.debug "Fetching Page #{"#".to_s.colorize(:blue) + page.to_s.colorize(:blue)}."
+
+        doc = Nokogiri::HTML request_video_html(page)
+        doc.css(".content-grid").css(".row").css(".content-grid-item").each do |element|
+          full_title = element.css(".caption-header").css(".title").text.strip
+          matched_title = full_title.match(SCENE_TITLE_REGEX)
+          next if matched_title.nil?
+
+          title = matched_title[:scene_title]
+          XxxRename.logger.debug("Extracted Scene #{title.to_s.colorize(:blue)}")
+          normalized_title = title.normalize
+
+          @response[normalized_title] = Data::SceneData.new(
+            {
+              collection: "NFBusty",
+              collection_tag: "NF",
+              title: title,
+              id: nil,
+              date_released: Time.strptime(element.css(".date").text.strip, "%b %e, %Y")
+            }.merge(actors_hash(element.css(".models").css(".model").map { |model| model.text.strip }))
+          )
+        end
+        return if last_page?(doc)
+
+        fetch_all_scenes(page + 1)
+      end
+
+      # @param [Integer] page
+      def request_video_html(page)
+        resp = self.class.get("/video/gallery/#{page * 12}").body
+        case resp.code
+        when 200 then resp
+        when 503 then raise SiteClients::Errors::SiteClientUnavailableError, self.class.base_uri
+        else raise "Something went wrong #{resp.code}"
+        end
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/query_generator/base.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "xxx_rename/utils"
+
+module XxxRename
+  module SiteClients
+    module QueryGenerator
+      class Base
+        SearchParameters = Struct.new(:title, :id, :female_actors, :movie, :collection,
+                                      :male_actors, :actors, :collection_tag, :date_released,
+                                      :processed, :index, keyword_init: true)
+
+        attr_reader :filename, :processed_file_patterns, :source_pattern
+
+        def self.generate(_filename, *_patterns)
+          raise "Not Implemented"
+        end
+
+        def self.generic_generate(filename, patterns)
+          new(filename, [], patterns).parse
+        end
+
+        # @param [String] filename
+        # @param [Array[String]] source_pattern
+        # @param [Array[String]] processed_file_patterns
+        def initialize(filename, source_pattern, processed_file_patterns)
+          @filename = File.basename(filename, File.extname(filename))
+          @source_pattern = source_pattern
+          @processed_file_patterns = processed_file_patterns
+        end
+
+        # Attempt to generate search parameters using three approaches
+        # 1. Use the source format if passed (handled by base)
+        # 2. Assume the file had already been processed and use `ProcessedFile` (handled by base using ProcessedFile.parse)
+        # 3. Use any formats given by the query generator
+        # 4. Treat the file as downloaded from official source (handled by each site client query generator)
+        # @return [Nil, XxxRename::Data::SceneData]
+        def parse
+          parse_file_with_source_pattern || # Use the user provided source format
+            parse_file || # Assume file format matches default format of CLI
+            parse_file_with_patterns # Use any formats given by the query generator
+        end
+
+        private
+
+        def parse_file
+          parse_file!
+        rescue XxxRename::Errors::ParsingError, Dry::Struct::Error
+          nil
+        end
+
+        def parse_file!
+          ProcessedFile.parse(filename)
+        end
+
+        def parse_file_with_source_pattern
+          parse_file_with_source_pattern!
+        rescue XxxRename::Errors::ParsingError, Dry::Struct::Error
+          nil
+        end
+
+        def parse_file_with_source_pattern!
+          source_pattern.map do |sp|
+            resp = ProcessedFile.strpfile(filename, sp)
+            return resp unless resp.nil?
+          end
+          nil
+        end
+
+        def parse_file_with_patterns
+          processed_file_patterns.compact
+                                 .map { |x| parse_file_with_pattern(x) }
+                                 .compact
+                                 .first
+        end
+
+        def parse_file_with_pattern!(pattern)
+          ProcessedFile.strpfile(filename, pattern)
+        end
+
+        def parse_file_with_pattern(pattern)
+          parse_file_with_pattern!(pattern)
+        rescue XxxRename::Errors::ParsingError, Dry::Struct::Error
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/query_generator/evil_angel.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/query_generator/base"
+
+module XxxRename
+  module SiteClients
+    module QueryGenerator
+      class EvilAngel < Base
+        extend Utils
+
+        def self.generate(filename, source_format)
+          if (data = new(filename, source_format, []).parse)
+            SearchParameters.new(
+              title: data.title,
+              id: data.id,
+              actors: data.actors,
+              processed: true
+            )
+          else
+            # Make sure to do this match to prevent unnecessary calls to API
+            return unless filename.match?(Constants::EVIL_ANGEL_ORIGINAL_FILE_PATTERN)
+
+            match = filename.match(Constants::EVIL_ANGEL_ORIGINAL_FILE_PATTERN)
+
+            SearchParameters.new(
+              actors: match[:actors]&.split("_"),
+              title: match[:title].titleize_custom,
+              index: match[:index],
+              processed: false
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/query_generator/goodporn.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/query_generator/base"
+
+module XxxRename
+  module SiteClients
+    module QueryGenerator
+      class Goodporn < Base
+        extend Utils
+
+        def self.generate(filename, source_format)
+          if (data = new(filename, source_format, []).parse)
+            "#{data.collection} #{data.title} #{data.date_released.strftime("%m %d %Y")}"
+              .downcase
+              .gsub(/[^\w\s]/, "")
+              .gsub(/\s+/, "-")
+          else
+            # Make sure to do this match to prevent unnecessary calls to API
+            return unless filename.match? Constants::GOODPORN_ORIGINAL_FILE_FORMAT
+
+            File.basename(filename, ".*").split("_")[0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/query_generator/mg_premium.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/query_generator/base"
+
+module XxxRename
+  module SiteClients
+    module QueryGenerator
+      class MgPremium < Base
+        extend Utils
+
+        def self.generate(filename, source_format)
+          if (data = new(filename, source_format, []).parse)
+            SearchParameters.new(title: data.title)
+          else
+            # Make sure to do this match to prevent unnecessary calls to API
+            return unless filename.match? Constants::MG_PREMIUM_ORIGINAL_FILE_FORMAT
+
+            basename = File.basename(filename, ".*")
+            scene_title = basename.split("_")&.first&.split("-")
+            SearchParameters.new(title: adjust_apostrophe(scene_title))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/query_generator/naughty_america.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/query_generator/base"
+
+module XxxRename
+  module SiteClients
+    module QueryGenerator
+      class NaughtyAmerica < Base
+        extend Utils
+
+        def self.generate(filename, source_format)
+          if (data = new(filename, source_format, []).parse)
+            SearchParameters.new(**data.to_h)
+          else
+            # Make sure to do this match to prevent unnecessary calls to API
+            return unless filename.match? Constants::NAUGHTY_AMERICA_ORIGINAL_FILE_REGEX
+
+            filename.match(Constants::NAUGHTY_AMERICA_ORIGINAL_FILE_REGEX)[:compressed_scene]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/query_generator/stash_db.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/query_generator/base"
+
+module XxxRename
+  module SiteClients
+    module QueryGenerator
+      class StashDb < Base
+        extend Utils
+
+        def self.generate(filename, source_format)
+          return unless (data = new(filename, source_format, []).parse)
+
+          SearchParameters.new(**data.to_h.slice(:title, :id, :female_actors, :movie, :collection,
+                                                 :male_actors, :actors, :collection_tag, :date_released,
+                                                 :processed, :index))
+        end
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/query_generator/vixen.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/query_generator/base"
+
+module XxxRename
+  module SiteClients
+    module QueryGenerator
+      class Vixen < Base
+        extend Utils
+
+        PATTERN_1 = "%actors [T] %title [S] %collection [ID] %id"
+
+        def self.generate(filename, source_format)
+          if (data = new(filename, source_format, [PATTERN_1]).parse)
+            SearchParameters.new(**data.to_h.slice(:title, :id, :female_actors, :collection, :male_actors, :actors))
+          else
+            re_match = filename.match(Constants::VIXEN_MEDIA_ORIGINAL_FILE_REGEX_1) ||
+                       filename.match(Constants::VIXEN_MEDIA_ORIGINAL_FILE_REGEX_2)
+            return if re_match.nil?
+
+            SearchParameters.new(id: re_match[:id], collection: re_match[:collection])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/query_generator/whale.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/query_generator/base"
+
+module XxxRename
+  module SiteClients
+    module QueryGenerator
+      class Whale < Base
+        extend Utils
+
+        # Generated using default format
+        PATTERN_1 = "%female_actors [T] %title [%collection_tag_2] %collection [ID] %id"
+        PATTERN_2 = "%female_actors [T] %title [%collection_tag_2] %collection"
+
+        def self.generate(filename, source_format)
+          query = new(filename, source_format, [PATTERN_1, PATTERN_2])
+          resp = query.parse
+          if resp
+            SearchParameters.new(
+              collection: resp.collection.normalize.to_sym,
+              title: resp.title&.downcase&.gsub(/\s/, "-"),
+              id: resp.id.to_s
+            )
+          else
+            match = filename.match(Constants::WHALE_ORIGINAL_FILE_PATTERN)
+            return if match.nil?
+
+            SearchParameters.new(
+              collection: match[:site]&.to_sym,
+              title: match[:title],
+              # At this time, we don't know what the id tag of the scene is
+              id: ""
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/reality_kings.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/mg_premium"
+
+module XxxRename
+  module SiteClients
+    class RealityKings < MGPremium
+      site_client_name :reality_kings
+      def initialize(config)
+        super(config, site_url: "https://www.realitykings.com")
+      end
+    end
+  end
+end