good_audible_story_sync 0.0.5

data/lib/good_audible_story_sync/goodreads/auth.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+# typed: true
+
+require "mechanize"
+
+module GoodAudibleStorySync
+  module Goodreads
+    class Auth
+      extend T::Sig
+
+      class Error < StandardError; end
+
+      BASE_URL = "https://www.goodreads.com"
+      CREDENTIALS_DB_KEY = "goodreads"
+
+      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)
+        url = page.uri.to_s
+        url.end_with?("/user/sign_in") || url.end_with?("/ap/signin")
+      end
+
+      sig { returns T.nilable(String) }
+      attr_reader :email, :profile_name, :user_id, :slug
+
+      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
+        @agent.user_agent_alias = "iPad"
+        @email = T.let(data["email"], T.nilable(String))
+        @password = T.let(data["password"], T.nilable(String))
+        @profile_name = T.let(data["profile_name"], T.nilable(String))
+        @user_id = T.let(data["user_id"], T.nilable(String))
+        @slug = T.let(data["slug"], T.nilable(String))
+      end
+
+      sig { returns(T.untyped) }
+      def sign_in
+        raise Error.new("Cannot sign in without credentials") if @email.nil? || @password.nil?
+
+        puts "#{Util::INFO_EMOJI} Signing into Goodreads as #{@email}..."
+        select_sign_in_page = begin
+          get("/user/sign_in")
+        rescue Errno::ETIMEDOUT => err
+          raise Error.new("Failed to load Goodreads: #{err}")
+        end
+
+        email_sign_in_link = T.let(select_sign_in_page.link_with(text: /Sign in with email/),
+          T.nilable(Mechanize::Page::Link))
+        raise Error.new("Failed to find sign-in link on #{select_sign_in_page.uri}") unless email_sign_in_link
+
+        email_sign_in_page = email_sign_in_link.click
+        sign_in_form = T.let(email_sign_in_page.form_with(name: "signIn"), T.nilable(Mechanize::Form))
+        raise Error.new("Could not find sign-in form on #{email_sign_in_page.uri}") unless sign_in_form
+
+        email_field = sign_in_form.field_with(name: "email")
+        raise Error.new("Could not find email field in sign-in form") unless email_field
+        password_field = sign_in_form.field_with(name: "password")
+        raise Error.new("Could not find password field in sign-in form") unless password_field
+
+        email_field.value = @email
+        password_field.value = @password
+        page_after_sign_in = begin
+          sign_in_form.submit
+        rescue Mechanize::ResponseCodeError => err
+          raise Error.new("Error signing into Goodreads: #{err}")
+        end
+
+        cookieless_message_el = page_after_sign_in.at("#ap_error_page_cookieless_message")
+        if cookieless_message_el
+          raise Error.new("Could not sign in to Goodreads without cookies: " \
+            "#{Util.squish(cookieless_message_el.text)}")
+        end
+
+        profile_link = T.let(page_after_sign_in.link_with(text: "Profile"), T.nilable(Mechanize::Page::Link))
+        successful_sign_in = !profile_link.nil? && !self.class.sign_in_page?(page_after_sign_in)
+        raise Error.new("Could not log in to Goodreads") unless successful_sign_in
+
+        profile_page = profile_link.click
+        profile_header = profile_page.at("h1")
+        @profile_name = if profile_header
+          profile_header.text.strip.split(/\n/).first
+        end
+        user_id_and_slug = profile_page.uri.path.split("/").last # e.g., "21047466-cheshire"
+        @user_id, @slug = user_id_and_slug.split("-")
+        puts "#{Util::SUCCESS_EMOJI} Signed in to Goodreads as #{@profile_name}"
+      end
+
+      sig { params(path: String).returns(Mechanize::Page) }
+      def get(path)
+        @agent.get("#{BASE_URL}#{path}")
+      end
+
+      sig { returns T::Hash[String, T.untyped] }
+      def to_h
+        {
+          "email" => @email,
+          "password" => @password,
+          "profile_name" => @profile_name,
+          "user_id" => @user_id,
+          "slug" => @slug,
+        }
+      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)
+        goodreads_data = cred_client.find(key: CREDENTIALS_DB_KEY)
+        unless goodreads_data
+          puts "#{Util::INFO_EMOJI} No Goodreads credentials found in database"
+          return false
+        end
+
+        @email = goodreads_data["email"]
+        @password = goodreads_data["password"]
+        @profile_name = goodreads_data["profile_name"]
+        @user_id = goodreads_data["user_id"]
+        @slug = goodreads_data["slug"]
+
+        true
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/goodreads/auth_flow.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+# typed: true
+
+require "io/console"
+
+module GoodAudibleStorySync
+  module Goodreads
+    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 Goodreads."
+        nil
+      end
+
+      private
+
+      sig { returns T.nilable(Auth) }
+      def load_from_database
+        auth = Auth.new
+        puts "#{Util::INFO_EMOJI} Looking for saved Goodreads credentials in database..."
+        success = auth.load_from_database(@credentials_db)
+        puts "#{Util::SUCCESS_EMOJI} Found saved Goodreads credentials." if success
+        return nil unless success
+
+        begin
+          auth.sign_in
+        rescue Auth::Error => err
+          puts "#{Util::ERROR_EMOJI} Failed to sign in to Goodreads: #{err.message}"
+          return nil
+        end
+
+        auth
+      end
+
+      sig { returns T.nilable(Auth) }
+      def log_in_via_website
+        puts "#{Util::INFO_EMOJI} Logging in to Goodreads..."
+        print "Enter Goodreads email: "
+        email = gets.chomp
+        print "Enter Goodreads 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 Goodreads: #{err.message}"
+          return nil
+        end
+
+        auth.save_to_database(@credentials_db)
+        auth
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/goodreads/book.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+# typed: true
+
+require "rainbow"
+require "uri"
+
+module GoodAudibleStorySync
+  module Goodreads
+    class Book
+      extend T::Sig
+
+      class Status < T::Enum
+        enums do
+          CurrentlyReading = new("currently-reading")
+          WantToRead = new("to-read")
+          Read = new("read")
+        end
+      end
+
+      # Public: From a `table#books tbody tr` element on a page like
+      # https://www.goodreads.com/review/list/21047466-cheshire?shelf=read.
+      sig { params(node: Nokogiri::XML::Element, page: Mechanize::Page).returns(Book) }
+      def self.from_book_list(node, page:)
+        name_el = node.at(".field.title .value")
+        raise "Could not find itemprop=name element for book list item on #{node.document.url}" unless name_el
+        link = name_el.at("a")
+        raise "Could not find book link for #{name_el.text} on #{node.document.url}" unless link
+        url = URI.parse(link["href"])
+        url.hostname ||= page.uri.hostname
+        url.scheme ||= page.uri.scheme
+        author_el = node.at(".field.author .value")
+        author = if author_el
+          value = author_el.text.strip
+          if value.include?(", ") # e.g., "Simmons, Dan"
+            value = value.split(", ").reverse.join(" ")
+          end
+          value
+        end
+        current_shelf_link = node.at(".field.shelves .value a")
+        isbn_el = node.at(".field.isbn .value")
+        new({
+          "title" => Util.squish(name_el.text),
+          "url" => url, # e.g., "https://www.goodreads.com/book/show/11286.Carrion_Comfort"
+          "slug" => url.path&.split("/")&.last, # e.g., "11286.Carrion_Comfort"
+          "author" => author,
+          "status" => current_shelf_link&.text, # e.g., "to-read"
+          "isbn" => isbn_el&.text&.strip,
+        })
+      end
+
+      sig { params(data: T::Hash[String, T.untyped]).void }
+      def initialize(data)
+        @data = data
+        raise "Cannot create a Goodreads book without a slug" unless @data["slug"] && !@data["slug"].empty?
+      end
+
+      sig { returns String }
+      def slug
+        @data["slug"]
+      end
+
+      sig { returns T.nilable(String) }
+      def isbn
+        @data["isbn"]
+      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 { 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 { returns T::Boolean }
+      def finished?
+        status == Status::Read
+      end
+
+      sig { returns T::Boolean }
+      def currently_reading?
+        status == Status::CurrentlyReading
+      end
+
+      sig { returns T::Boolean }
+      def want_to_read?
+        status == Status::WantToRead
+      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}/book/show/#{slug}"
+        @url_by_stylize[stylize] = if stylize
+          Rainbow(value).blue
+        else
+          value
+        end
+      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 (slug #{slug})"
+        end
+      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 { returns String }
+      def inspect
+        @data.inspect
+      end
+
+      sig { returns T::Hash[String, T.untyped] }
+      def to_h
+        @data.dup
+      end
+
+      sig { params(books_db: Database::GoodreadsBooks).returns(T::Boolean) }
+      def save_to_database(books_db)
+        books_db.upsert(slug: slug, title: title, author: author,
+          isbn: isbn, status: status&.serialize)
+        true
+      end
+
+      sig { params(prefix: String, stylize: T::Boolean).returns(T.nilable(String)) }
+      def status_summary(prefix: " - ", stylize: false)
+        suffix = if finished?
+          "Finished"
+        elsif currently_reading?
+          "Currently reading"
+        elsif want_to_read?
+          "Want to read"
+        else
+          status&.serialize
+        end
+        if suffix
+          value = "#{prefix}#{suffix}"
+          stylize ? Rainbow(value).italic : value
+        end
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/goodreads/client.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+# typed: true
+
+require "mechanize"
+require "rainbow"
+
+module GoodAudibleStorySync
+  module Goodreads
+    class Client
+      extend T::Sig
+
+      BASE_URL = Auth::BASE_URL
+
+      class Error < StandardError; end
+      class NotAuthenticatedError < StandardError; end
+
+      sig { returns Mechanize }
+      attr_reader :agent
+
+      sig { params(auth: Auth).void }
+      def initialize(auth:)
+        @agent = T.let(auth.agent, Mechanize)
+        @auth = auth
+      end
+
+      # e.g., https://www.goodreads.com/review/list/21047466-cheshire?shelf=read
+      sig do
+        params(
+          page: Integer,
+          load_all_pages: T::Boolean,
+          process_book: T.nilable(T.proc.params(arg0: Book).void)
+        ).returns(Library)
+      end
+      def get_read_books(page: 1, load_all_pages: true, process_book: nil)
+        initial_page = get("/review/list/#{@auth.user_id}-#{@auth.slug}?shelf=read&page=#{page}")
+        library = Library.new
+        books = get_read_books_on_page(page: initial_page, load_all_pages: load_all_pages,
+          process_book: process_book)
+        books.each { |book| library.add_book(book) }
+        library
+      end
+
+      sig { params(path: String).returns(Mechanize::Page) }
+      def get(path)
+        url = "#{BASE_URL}#{path}"
+        puts "#{Util::INFO_EMOJI} GET #{Rainbow(url).blue}"
+        load_page(-> { @agent.get(url) })
+      end
+
+      private
+
+      sig do
+        params(
+          path: T.nilable(String),
+          page: T.nilable(Mechanize::Page),
+          load_all_pages: T::Boolean,
+          process_book: T.nilable(T.proc.params(arg0: Book).void)
+        ).returns(T::Array[Book])
+      end
+      def get_read_books_on_page(path: nil, page: nil, load_all_pages: true, process_book: nil)
+        if path
+          page = get(path)
+        elsif page.nil?
+          raise "Either a relative URL or a page must be provided"
+        end
+
+        book_elements = T.let(page.search("table#books tbody tr"), Nokogiri::XML::NodeSet)
+        books = book_elements.map { |el| Book.from_book_list(el, page: page) }
+        puts "#{Util::WARNING_EMOJI} No books found on #{page.uri}" if books.empty?
+        books.each { |book| process_book.call(book) } if process_book
+
+        if load_all_pages
+          next_page_link = page.at("a.next_page")
+          if next_page_link
+            units = books.size == 1 ? "book" : "books"
+            print "#{Util::INFO_EMOJI} Found #{books.size} #{units} on page"
+            last_book = books.last
+            print ", ending with #{last_book.title_and_author}" if last_book
+            puts
+
+            books += get_read_books_on_page(path: next_page_link["href"],
+              load_all_pages: load_all_pages, process_book: process_book)
+          end
+        end
+
+        books
+      end
+
+      sig { params(make_request: T.proc.returns(Mechanize::Page)).returns(Mechanize::Page) }
+      def load_page(make_request)
+        page = make_request.call
+        raise NotAuthenticatedError if Auth.sign_in_page?(page)
+        sleep 1 # don't hammer the server
+        page
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/goodreads/library.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+# typed: true
+
+module GoodAudibleStorySync
+  module Goodreads
+    class Library
+      extend T::Sig
+
+      SYNC_TIME_KEY = "goodreads_library"
+
+      sig { params(client: Client, db_client: Database::Client, options: Options).returns(Library) }
+      def self.load(client:, db_client:, options:)
+        library_cache_last_modified = db_client.sync_times.find(SYNC_TIME_KEY)&.to_time
+        library_is_cached = !library_cache_last_modified.nil?
+        should_refresh_library = library_cache_last_modified &&
+          library_cache_last_modified > options.refresh_cutoff_time
+
+        if library_is_cached && should_refresh_library
+          load_from_database(db_client.goodreads_books)
+        else
+          if library_is_cached
+            puts "#{Util::INFO_EMOJI} Goodreads library cache has not been updated " \
+              "since #{Util.pretty_time(library_cache_last_modified)}, updating..."
+          end
+          load_from_web(client: client, db_client: db_client)
+        end
+      end
+
+      sig { params(client: Client, db_client: Database::Client).returns(Library) }
+      def self.load_from_web(client:, db_client:)
+        books_db = db_client.goodreads_books
+        save_book = T.let(
+          ->(book) { book.save_to_database(books_db) },
+          T.proc.params(arg0: GoodAudibleStorySync::Goodreads::Book).void
+        )
+        library = client.get_read_books(process_book: save_book)
+        library.update_sync_time(db_client.sync_times)
+        library
+      end
+
+      sig { params(books_db: Database::GoodreadsBooks).returns(Library) }
+      def self.load_from_database(books_db)
+        library = new
+        library.load_from_database(books_db)
+        library
+      end
+
+      sig { void }
+      def initialize
+        @books_by_slug = T.let({}, T::Hash[String, Book])
+      end
+
+      sig { returns T::Array[Book] }
+      def books
+        @books_by_slug.values
+      end
+
+      sig { params(book: Book).void }
+      def add_book(book)
+        @books_by_slug[book.slug] = book
+      end
+
+      sig { returns T::Array[Book] }
+      def finished_books
+        calculate_finished_unfinished_books
+        @finished_books
+      end
+
+      sig { returns Integer }
+      def total_finished
+        @total_finished ||= finished_books.size
+      end
+
+      sig { returns Integer }
+      def total_books
+        @books_by_slug.size
+      end
+
+      sig { returns Integer }
+      def finished_percent
+        @finished_percent ||= (total_finished.to_f / total_books * 100).round
+      end
+
+      sig { returns String }
+      def finished_book_units
+        total_finished == 1 ? "book" : "books"
+      end
+
+      sig { returns String }
+      def book_units
+        total_books == 1 ? "book" : "books"
+      end
+
+      sig { params(books_db: Database::GoodreadsBooks).returns(T::Boolean) }
+      def load_from_database(books_db)
+        puts "#{Util::INFO_EMOJI} Loading cached Goodreads library..."
+
+        rows = books_db.find_all
+        rows.each { |row| add_book(Book.new(row)) }
+
+        true
+      end
+
+      sig { params(sync_times_db: Database::SyncTimes).void }
+      def update_sync_time(sync_times_db)
+        puts "#{Util::SAVE_EMOJI} Updating time Goodreads library was last cached..."
+        sync_times_db.touch(SYNC_TIME_KEY)
+      end
+
+      sig { params(limit: Integer, stylize: T::Boolean).returns(String) }
+      def to_s(limit: 5, stylize: false)
+        [
+          "📚 Found #{total_books} #{book_units} on Goodreads",
+          finished_books_summary(limit: limit, stylize: stylize),
+        ].compact.join("\n")
+      end
+
+      sig { params(limit: Integer, stylize: T::Boolean).returns(String) }
+      def finished_books_summary(limit: 5, stylize: false)
+        lines = T.let([
+          "#{Util::DONE_EMOJI} #{total_finished} #{finished_book_units} " \
+            "(#{finished_percent}%) in Goodreads library have been finished:",
+        ], T::Array[String])
+        lines.concat(finished_books.take(limit).map { |book| book.to_s(indent_level: 1, stylize: stylize) })
+        lines << "#{Util::TAB}..." if total_finished > limit
+        lines << ""
+        lines.join("\n")
+      end
+
+      sig { returns String }
+      def to_json
+        JSON.pretty_generate(books.map(&:to_h))
+      end
+
+      sig { params(isbn: String).returns(T.nilable(Book)) }
+      def find_by_isbn(isbn)
+        books.detect { |book| book.isbn == isbn }
+      end
+
+      private
+
+      sig { void }
+      def calculate_finished_unfinished_books
+        return if @finished_books && @unfinished_books
+        @finished_books, @unfinished_books = books.partition(&:finished?)
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/goodreads.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module GoodAudibleStorySync
+  module Goodreads
+  end
+end
+
+require_relative "goodreads/auth"
+require_relative "goodreads/auth_flow"
+require_relative "goodreads/book"
+require_relative "goodreads/client"
+require_relative "goodreads/library"