good_audible_story_sync 0.0.5

data/lib/good_audible_story_sync/input_loop.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+# typed: true
+
+require "rainbow"
+
+module GoodAudibleStorySync
+  class InputLoop
+    extend T::Sig
+
+    class UserCommand < T::Enum
+      enums do
+        DisplayAudibleLibrary = new("a")
+        DisplayAudibleUserProfile = new("p")
+        DisplayGoodreadsLibrary = new("g")
+        DisplayStorygraphLibrary = new("s")
+        UpdateStorygraphLibraryCache = new("c")
+        MarkFinishedBooks = new("f")
+        LookUpStorygraphBook = new("l")
+        Quit = new("q")
+      end
+    end
+
+    sig { params(script_name: String).void }
+    def self.run(script_name:)
+      new(script_name: script_name).run
+    end
+
+    sig { params(script_name: String).void }
+    def initialize(script_name:)
+      @script_name = script_name
+    end
+
+    sig { void }
+    def run
+      options # parse command line options
+      db_client # set up database tables
+
+      loop do
+        print_options
+        cmd = get_user_command
+        process_command(cmd)
+        puts
+      end
+    end
+
+    private
+
+    sig { void }
+    def print_options
+      print_option(UserCommand::DisplayAudibleLibrary, "display Audible library")
+      print_option(UserCommand::DisplayAudibleUserProfile, "display Audible user profile")
+      print_option(UserCommand::DisplayGoodreadsLibrary, "display Goodreads library")
+      print_option(UserCommand::DisplayStorygraphLibrary, "display Storygraph library")
+      print_option(UserCommand::LookUpStorygraphBook, "look up book on Storygraph")
+      print_option(UserCommand::UpdateStorygraphLibraryCache, "update Storygraph library cache")
+      print_option(UserCommand::MarkFinishedBooks, "mark finished books on Storygraph")
+      print_option(UserCommand::Quit, "quit")
+    end
+
+    sig { params(option: UserCommand, description: String).void }
+    def print_option(option, description)
+      Util.print_option(option.serialize, description)
+    end
+
+    sig { returns UserCommand }
+    def get_user_command
+      cmd = T.let(nil, T.nilable(UserCommand))
+      while cmd.nil?
+        print "Choose an option: "
+        input = gets.chomp
+        cmd = UserCommand.try_deserialize(input)
+        puts "Invalid command" if cmd.nil?
+      end
+      cmd
+    end
+
+    sig { params(cmd: UserCommand).void }
+    def process_command(cmd)
+      case cmd
+      when UserCommand::DisplayAudibleLibrary then display_audible_library
+      when UserCommand::DisplayAudibleUserProfile then display_audible_user_profile
+      when UserCommand::DisplayGoodreadsLibrary then display_goodreads_library
+      when UserCommand::DisplayStorygraphLibrary then display_storygraph_library
+      when UserCommand::UpdateStorygraphLibraryCache then update_storygraph_library_cache
+      when UserCommand::MarkFinishedBooks then mark_finished_books
+      when UserCommand::Quit then quit
+      when UserCommand::LookUpStorygraphBook then look_up_storygraph_book
+      else
+        T.absurd(cmd)
+      end
+    end
+
+    sig { void }
+    def look_up_storygraph_book
+      Storygraph::LookUpBookFlow.run(client: storygraph_client, books_db: db_client.storygraph_books)
+    end
+
+    sig { void }
+    def display_audible_library
+      puts audible_library.to_s(stylize: true)
+    end
+
+    sig { returns Audible::Library }
+    def audible_library
+      @audible_library ||= Audible::Library.load_with_finish_times(client: audible_client,
+        options: options, db_client: db_client)
+    end
+
+    sig { void }
+    def display_goodreads_library
+      puts goodreads_library.to_s(stylize: true)
+    end
+
+    sig { void }
+    def display_storygraph_library
+      puts storygraph_library.to_s(stylize: true)
+    end
+
+    sig { void }
+    def update_storygraph_library_cache
+      @storygraph_library = Storygraph::Library.load_from_web(client: storygraph_client,
+        db_client: db_client)
+    end
+
+    sig { returns Goodreads::Library }
+    def goodreads_library
+      @goodreads_library ||= Goodreads::Library.load(client: goodreads_client, db_client: db_client, options: options)
+    end
+
+    sig { returns Storygraph::Library }
+    def storygraph_library
+      @storygraph_library ||= Storygraph::Library.load(client: storygraph_client,
+        db_client: db_client, options: options)
+    end
+
+    sig { void }
+    def display_audible_user_profile
+      puts "#{Util::INFO_EMOJI} Getting Audible user profile..."
+      user_profile = audible_client.get_user_profile
+      puts user_profile.to_s(indent_level: 1)
+    end
+
+    sig { void }
+    def mark_finished_books
+      Storygraph::MarkFinishedFlow.run(
+        audible_library: audible_library,
+        library: storygraph_library,
+        client: storygraph_client,
+        db_client: db_client,
+      )
+    end
+
+    sig { void }
+    def quit
+      puts "Goodbye!"
+      exit 0
+    end
+
+    sig { returns Audible::Client }
+    def audible_client
+      @audible_client ||= Audible::Client.new(auth: audible_auth, options: options,
+        credentials_db: db_client.credentials)
+    end
+
+    sig { returns Audible::Auth }
+    def audible_auth
+      return @audible_auth if @audible_auth
+      maybe_auth = GoodAudibleStorySync::Audible::AuthFlow.run(db_client: db_client)
+      exit 1 if maybe_auth.nil?
+      @audible_auth = maybe_auth
+    end
+
+    sig { returns Goodreads::Client }
+    def goodreads_client
+      @goodreads_client ||= Goodreads::Client.new(auth: goodreads_auth)
+    end
+
+    sig { returns Storygraph::Client }
+    def storygraph_client
+      @storygraph_client ||= Storygraph::Client.new(auth: storygraph_auth)
+    end
+
+    sig { returns Storygraph::Auth }
+    def storygraph_auth
+      return @storygraph_auth if @storygraph_auth
+      maybe_auth = Storygraph::AuthFlow.run(credentials_db: db_client.credentials)
+      exit 1 if maybe_auth.nil?
+      @storygraph_auth = maybe_auth
+    end
+
+    sig { returns Goodreads::Auth }
+    def goodreads_auth
+      return @goodreads_auth if @goodreads_auth
+      maybe_auth = Goodreads::AuthFlow.run(credentials_db: db_client.credentials)
+      exit 1 if maybe_auth.nil?
+      @goodreads_auth = maybe_auth
+    end
+
+    sig { returns Database::Client }
+    def db_client
+      @db_client ||= Database::Client.load(options.database_file, cipher: cipher)
+    end
+
+    sig { returns Options }
+    def options
+      @options ||= Options.parse(script_name: @script_name, cipher: cipher)
+    end
+
+    sig { returns Util::Cipher }
+    def cipher
+      @cipher ||= Util::Cipher.new
+    end
+  end
+end

data/lib/good_audible_story_sync/options.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+# typed: true
+# encoding: utf-8
+
+require "optparse"
+
+module GoodAudibleStorySync
+  class Options
+    extend T::Sig
+
+    EMOJI_PREFIX = "⚙️"
+    DEFAULT_EXPIRATION_DAYS = 1
+
+    # sig { returns Options }
+    def self.default
+      parse(script_name: File.basename($0))
+    end
+
+    # sig { params(script_name: String, cipher: T.nilable(Util::Cipher), argv: Array).returns(Options) }
+    def self.parse(script_name:, cipher: nil, argv: ARGV)
+      puts "#{EMOJI_PREFIX} Parsing options..."
+      options = new(script_name: script_name, cipher: cipher, argv: argv)
+      options.parse
+      options
+    end
+
+    # sig { params(script_name: String, cipher: T.nilable(Util::Cipher), argv: Array).void }
+    def initialize(script_name:, cipher: nil, argv: ARGV)
+      @options = {}
+      @argv = argv
+      @cipher = cipher || Util::Cipher.new
+      @option_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{script_name} [options]"
+        opts.on(
+          "-d DATABASE_FILE",
+          "--database-file",
+          String,
+          "Path to Sqlite database file. Defaults to #{Database::Client::DEFAULT_DATABASE_FILE}.",
+        )
+        opts.on(
+          "-e EXPIRATION_DAYS",
+          "--expiration-days",
+          Integer,
+          "Max number of days to use cached data, such as Audible library, before " \
+            "refreshing. Defaults to #{DEFAULT_EXPIRATION_DAYS}.",
+        )
+      end
+
+      # sig { void }
+      def parse
+        @option_parser.parse!(@argv, into: @options)
+      end
+
+      # sig { returns String }
+      def database_file
+        @database_file ||= @options[:"database-file"] || Database::Client::DEFAULT_DATABASE_FILE
+      end
+
+      # sig { returns Integer }
+      def expiration_days
+        @expiration_days ||= @options[:"expiration-days"] || DEFAULT_EXPIRATION_DAYS
+      end
+
+      # sig { returns Time }
+      def refresh_cutoff_time
+        Time.now - (expiration_days * 86400)
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/storygraph/auth.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+# typed: true
+
+require "mechanize"
+
+module GoodAudibleStorySync
+  module Storygraph
+    class Auth
+      extend T::Sig
+
+      BASE_URL = "https://app.thestorygraph.com"
+      CREDENTIALS_DB_KEY = "storygraph"
+
+      class Error < StandardError; end
+
+      sig { params(email: String, password: String).returns(Auth) }
+      def self.sign_in(email:, password:)
+        auth = new(data: { "email" => email, "password" => password })
+        auth.sign_in
+        auth
+      end
+
+      sig { params(page: Mechanize::Page).returns(T::Boolean) }
+      def self.sign_in_page?(page)
+        page.uri.to_s.end_with?("/users/sign_in")
+      end
+
+      sig { returns T.nilable(String) }
+      attr_reader :email, :username
+
+      sig { returns Mechanize }
+      attr_reader :agent
+
+      sig { params(agent: T.nilable(Mechanize), data: T::Hash[String, T.nilable(String)]).void }
+      def initialize(agent: nil, data: {})
+        @agent = agent || Mechanize.new
+        @email = data["email"]
+        @password = data["password"]
+        @username = data["username"]
+      end
+
+      sig { void }
+      def sign_in
+        raise Error.new("Cannot sign in without credentials") if @email.nil? || @password.nil?
+
+        puts "#{Util::INFO_EMOJI} Signing into Storygraph as #{@email}..."
+        page = begin
+          @agent.get("#{BASE_URL}/users/sign_in")
+        rescue Errno::ETIMEDOUT => err
+          raise Error.new("Failed to load sign-in page: #{err}")
+        end
+        sign_in_form = page.form_with(action: "/users/sign_in") do |form|
+          form["user[email]"] = @email
+          form["user[password]"] = @password
+        end
+        page_after_sign_in = sign_in_form.submit
+        profile_link = page_after_sign_in.link_with(text: "Profile")
+        successful_sign_in = !profile_link.nil? && !self.class.sign_in_page?(page_after_sign_in)
+        raise Error.new("Invalid credentials") unless successful_sign_in
+
+        @username = profile_link.href.split("/profile/").last
+        puts "#{Util::SUCCESS_EMOJI} Successfully signed in to Storygraph as #{username}"
+      end
+
+      sig { returns T::Hash[String, T.untyped] }
+      def to_h
+        { "email" => @email, "password" => @password, "username" => @username }
+      end
+
+      sig { params(cred_client: Database::Credentials).void }
+      def save_to_database(cred_client)
+        cred_client.upsert(key: CREDENTIALS_DB_KEY, value: to_h)
+      end
+
+      sig { params(cred_client: Database::Credentials).returns(T::Boolean) }
+      def load_from_database(cred_client)
+        storygraph_data = cred_client.find(key: CREDENTIALS_DB_KEY)
+        unless storygraph_data
+          puts "#{Util::INFO_EMOJI} No Storygraph credentials found in database"
+          return false
+        end
+
+        @email = storygraph_data["email"]
+        @password = storygraph_data["password"]
+        @username = storygraph_data["username"]
+
+        true
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/storygraph/auth_flow.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+# typed: true
+
+require "io/console"
+
+module GoodAudibleStorySync
+  module Storygraph
+    class AuthFlow
+      extend T::Sig
+
+      sig { params(credentials_db: Database::Credentials).returns(T.nilable(Auth)) }
+      def self.run(credentials_db:)
+        new(credentials_db: credentials_db).run
+      end
+
+      sig { params(credentials_db: Database::Credentials).void }
+      def initialize(credentials_db:)
+        @credentials_db = credentials_db
+      end
+
+      sig { returns T.nilable(Auth) }
+      def run
+        load_from_database || log_in_via_website
+      rescue Auth::Error
+        puts "Failed to sign in to Storygraph."
+        nil
+      end
+
+      private
+
+      sig { returns T.nilable(Auth) }
+      def load_from_database
+        auth = Auth.new
+        puts "#{Util::INFO_EMOJI} Looking for saved Storygraph credentials in database..."
+        success = auth.load_from_database(@credentials_db)
+        puts "#{Util::SUCCESS_EMOJI} Found saved Storygraph credentials." if success
+        return nil unless success
+
+        begin
+          auth.sign_in
+        rescue Auth::Error => err
+          puts "#{Util::ERROR_EMOJI} Failed to sign in to Storygraph: #{err.message}"
+          return nil
+        end
+
+        auth
+      end
+
+      sig { returns T.nilable(Auth) }
+      def log_in_via_website
+        puts "#{Util::INFO_EMOJI} Logging in to Storygraph..."
+        print "Enter Storygraph email: "
+        email = gets.chomp
+        print "Enter Storygraph password: "
+        password = T.unsafe(STDIN).noecho(&:gets).chomp
+        print "\n"
+
+        auth = begin
+          Auth.sign_in(email: email, password: password)
+        rescue Auth::Error => err
+          puts "#{Util::ERROR_EMOJI} Failed to sign in to Storygraph: #{err.message}"
+          return nil
+        end
+
+        auth.save_to_database(@credentials_db)
+        auth
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/storygraph/book.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+# typed: true
+
+require "date"
+require "rainbow"
+
+module GoodAudibleStorySync
+  module Storygraph
+    class Book
+      extend T::Sig
+
+      class Status < T::Enum
+        enums do
+          CurrentlyReading = new("currently reading")
+          DidNotFinish = new("did not finish")
+          ToRead = new("to read")
+          Read = new("read")
+        end
+      end
+
+      # Public: From .book-pane element on a URL like
+      # https://app.thestorygraph.com/books-read/cheshire137.
+      sig do
+        params(
+          book_pane: Nokogiri::XML::Element,
+          page: Mechanize::Page,
+          extra_data: T::Hash[String, T.untyped]
+        ).returns(Book)
+      end
+      def self.from_read_book(book_pane, page:, extra_data: {})
+        title_link = book_pane.at(".book-title-author-and-series h3 a")
+        raise "No title link found on #{page.uri}" unless title_link
+
+        author_el = book_pane.search(".book-title-author-and-series p").last
+        read_status_label = book_pane.at(".read-status-label")
+
+        new({
+          "title" => Util.squish(title_link.text.strip),
+          "author" => Util.squish(author_el&.text&.strip),
+          "url" => "#{page.uri.origin}#{title_link["href"]}",
+          "id" => book_pane["data-book-id"],
+          "finished_on" => extract_finish_date(book_pane),
+          "status" => read_status_label&.text&.strip&.downcase || Status::Read.serialize,
+        }.merge(extra_data))
+      end
+
+      # Public: From a page like
+      # https://app.thestorygraph.com/books/96b3360a-289c-4e1c-b463-f9f0f5b72a0e.
+      sig { params(page: Mechanize::Page, extra_data: T::Hash[String, T.untyped]).returns(Book) }
+      def self.from_book_page(page, extra_data: {})
+        title_header = page.at(".book-title-author-and-series h3")
+        raise "No title header found on page #{page.uri}" unless title_header
+
+        book_id_node = page.at("[data-book-id]")
+        book_id = if book_id_node
+          book_id_node["data-book-id"]
+        else
+          page.uri.path.split("/books/").last
+        end
+
+        author_link = page.at(".book-title-author-and-series a")
+        read_status_label = page.at(".read-status-label")
+
+        new({
+          "id" => book_id,
+          "title" => Util.squish(title_header.text.strip),
+          "author" => Util.squish(author_link&.text&.strip),
+          "url" => page.uri.to_s,
+          "finished_on" => extract_finish_date(page),
+          "status" => read_status_label&.text&.strip&.downcase,
+        }.merge(extra_data))
+      end
+
+      sig { params(data: T::Hash[String, T.untyped]).void }
+      def initialize(data)
+        @data = data
+      end
+
+      sig { returns T.nilable(Date) }
+      def finished_on
+        return @finished_on if defined?(@finished_on)
+        date_or_str = @data["finished_on"]
+        return if date_or_str.nil?
+        @finished_on = date_or_str.is_a?(String) ? Date.parse(date_or_str) : date_or_str
+      end
+
+      sig { params(value: T.nilable(Date)).void }
+      def finished_on=(value)
+        @finished_on = value
+        @data["finished_on"] = value.to_s
+      end
+
+      sig { returns T::Boolean }
+      def finished?
+        !finished_on.nil? || status == Status::Read
+      end
+
+      sig { returns T::Boolean }
+      def currently_reading?
+        status == Status::CurrentlyReading
+      end
+
+      sig { returns T::Boolean }
+      def did_not_finish?
+        status == Status::DidNotFinish
+      end
+
+      sig { returns T::Boolean }
+      def want_to_read?
+        status == Status::ToRead
+      end
+
+      sig { params(other_book: Book).returns(T::Boolean) }
+      def copy_from(other_book)
+        unless id == other_book.id
+          raise "Cannot merge Storygraph books with different IDs: #{id} and #{other_book.id}"
+        end
+
+        puts "#{Util::INFO_EMOJI} Updating book info for #{id}..."
+        any_updates = T.let(false, T::Boolean)
+
+        other_book.to_h.each do |key, value|
+          next unless value
+
+          if @data[key].nil? || @data[key].is_a?(String) && @data[key].empty?
+            puts "#{Util::TAB}Setting #{key} => #{value}"
+            @data[key] = value
+            any_updates = true
+          end
+        end
+
+        any_updates
+      end
+
+      sig { returns T.nilable(String) }
+      def id
+        @data["id"]
+      end
+
+      sig { returns T.nilable(String) }
+      def isbn
+        @data["isbn"]
+      end
+
+      sig { returns T.nilable(Status) }
+      def status
+        value = @data["status"]
+        return value if value.nil? || value.is_a?(Status)
+        Status.try_deserialize(value.to_s)
+      end
+
+      sig { params(stylize: T::Boolean).returns(T.nilable(String)) }
+      def title(stylize: false)
+        value = @data["title"]
+        return value unless stylize && value
+        Rainbow(value).underline
+      end
+
+      sig { returns T.nilable(String) }
+      def author
+        @data["author"]
+      end
+
+      sig { params(stylize: T::Boolean).returns(T.nilable(String)) }
+      def url(stylize: false)
+        @url_by_stylize ||= {}
+        return @url_by_stylize[stylize] if @url_by_stylize[stylize]
+        value = @data["url"] || "#{Client::BASE_URL}/books/#{id}"
+        @url_by_stylize[stylize] = if stylize
+          Rainbow(value).blue
+        else
+          value
+        end
+      end
+
+      sig { params(books_db: Database::StorygraphBooks).returns(T::Boolean) }
+      def save_to_database(books_db)
+        id = self.id
+        return false unless id
+
+        books_db.upsert(id: id, title: title, author: author, finished_on: finished_on,
+          isbn: isbn, status: status&.serialize)
+
+        true
+      end
+
+      sig { params(indent_level: Integer, stylize: T::Boolean).returns(String) }
+      def to_s(indent_level: 0, stylize: false)
+        line1 = "#{Util::TAB * indent_level}#{title_and_author(stylize: stylize)}" \
+          "#{status_summary(stylize: stylize)}"
+        lines = [
+          line1,
+          "#{Util::TAB * (indent_level + 1)}#{Util::NEWLINE_EMOJI} #{url(stylize: stylize)}",
+        ]
+        lines.join("\n")
+      end
+
+      sig { params(stylize: T::Boolean).returns(String) }
+      def title_and_author(stylize: false)
+        @title_and_author_by_stylize ||= {}
+        return @title_and_author_by_stylize[stylize] if @title_and_author_by_stylize[stylize]
+        author = self.author
+        @title_and_author_by_stylize[stylize] = if author && !author.empty?
+          "#{title(stylize: stylize)} by #{author}"
+        else
+          title(stylize: stylize) || "Unknown (ID #{id})"
+        end
+      end
+
+      sig { params(prefix: String, stylize: T::Boolean).returns(T.nilable(String)) }
+      def status_summary(prefix: " - ", stylize: false)
+        finished_on = self.finished_on
+        suffix = if finished_on
+          "Finished #{Util.pretty_date(finished_on)}"
+        elsif finished?
+          "Finished"
+        elsif currently_reading?
+          "Currently reading"
+        elsif did_not_finish?
+          "Did not finish"
+        elsif want_to_read?
+          "Want to read"
+        else
+          status&.serialize
+        end
+        if suffix
+          value = "#{prefix}#{suffix}"
+          stylize ? Rainbow(value).italic : value
+        end
+      end
+
+      sig { returns String }
+      def inspect
+        @data.inspect
+      end
+
+      sig { returns T::Hash[String, T.untyped] }
+      def to_h
+        @data.dup
+      end
+
+      sig do
+        params(node_or_page: T.any(Nokogiri::XML::Element, Mechanize::Page)).returns(T.nilable(String))
+      end
+      def self.extract_finish_date(node_or_page)
+        finish_date_prefix = "Finished "
+        finished_el = node_or_page.search(".action-menu p").detect do |el|
+          el.text.start_with?(finish_date_prefix)
+        end
+        if finished_el
+          # e.g., "Dec 20, 2024\n              \n                Click to edit read date"
+          date_str_and_extra = finished_el.text.split(finish_date_prefix).last
+
+          # e.g., "Dec 20, 2024"
+          date_str_and_extra.split("\n").first
+        end
+      end
+      private_class_method :extract_finish_date
+    end
+  end
+end