good_audible_story_sync 0.0.5

data/lib/good_audible_story_sync/storygraph/mark_finished_flow.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+# typed: true
+
+module GoodAudibleStorySync
+  module Storygraph
+    class MarkFinishedFlow
+      extend T::Sig
+
+      class UserCommand < T::Enum
+        enums do
+          SetReadDate = new("r")
+          NextBook = new("n")
+          Cancel = new("c")
+          Quit = new("q")
+        end
+      end
+
+      sig do
+        params(
+          audible_library: Audible::Library,
+          library: Library,
+          client: Client,
+          db_client: Database::Client
+        ).void
+      end
+      def self.run(audible_library:, library:, client:, db_client:)
+        new(audible_library: audible_library, library: library, client: client,
+          db_client: db_client).run
+      end
+
+      sig do
+        params(
+          audible_library: Audible::Library,
+          library: Library,
+          client: Client,
+          db_client: Database::Client
+        ).void
+      end
+      def initialize(audible_library:, library:, client:, db_client:)
+        @audible_library = audible_library
+        @library = library
+        @client = client
+        @db_client = db_client
+        @current_book = T.let(nil, T.nilable(Book))
+        @current_finish_date = T.let(nil, T.nilable(Date))
+        @stop_marking_finished = T.let(false, T::Boolean)
+      end
+
+      sig { void }
+      def run
+        finish_dates_by_isbn.each do |isbn, finish_date|
+          @current_finish_date = finish_date
+          process_book(isbn)
+          break if @stop_marking_finished
+        end
+      end
+
+      private
+
+      sig { params(isbn: String).void }
+      def process_book(isbn)
+        @current_book = find_book_by_isbn(isbn)
+        return unless @current_book
+
+        storygraph_finish_date = @current_book.finished_on
+        title_and_author = @current_book.title_and_author(stylize: true)
+
+        if storygraph_finish_date.nil?
+          puts "#{Util::INFO_EMOJI} Storygraph book #{title_and_author} has no finish date"
+          prompt_user_about_current_book
+        elsif storygraph_finish_date == @current_finish_date
+          puts "#{Util::SUCCESS_EMOJI} Storygraph book #{title_and_author} already " \
+            "marked as finished on #{Util.pretty_date(@current_finish_date)}"
+        else
+          puts "#{Util::WARNING_EMOJI} #{title_and_author}"
+          puts "#{Util::TAB}Storygraph finish date: #{Util.pretty_date(storygraph_finish_date)}"
+          puts "#{Util::TAB}Versus Audible: #{Util.pretty_date(T.must(@current_finish_date))}"
+          prompt_user_about_current_book
+        end
+      end
+
+      sig { params(isbn: String).returns(T.nilable(Book)) }
+      def find_book_by_isbn(isbn)
+        audible_book = @audible_library.find_by_isbn(isbn)
+        if audible_book
+          puts "#{Util::INFO_EMOJI}Looking up #{audible_book.to_s(stylize: true)} on Storygraph..."
+        end
+
+        # Do we already have the book associated with the ISBN in the local database?
+        book = @library.find_by_isbn(isbn)
+
+        unless book
+          # If not, search for it on Storygraph using the ISBN, then by title and author
+          book = @client.find_by_isbn(isbn, fallback_query: audible_book&.search_query)
+
+          if book
+            # Associate the book with its ISBN in the local library database
+            @library.add_book(book)
+            book.save_to_database(@db_client.storygraph_books)
+          else
+            puts "#{Util::WARNING_EMOJI} Book with ISBN #{isbn} not found on Storygraph"
+          end
+        end
+
+        book
+      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 { void }
+      def prompt_user_about_current_book
+        book = T.must(@current_book)
+        puts book.to_s(stylize: true)
+        print_options
+        cmd = get_user_command
+        process_command(cmd)
+        puts
+      end
+
+      sig { params(cmd: UserCommand).void }
+      def process_command(cmd)
+        case cmd
+        when UserCommand::Quit then quit
+        when UserCommand::NextBook then skip_current_book
+        when UserCommand::SetReadDate then set_read_date_on_current_book
+        when UserCommand::Cancel then cancel
+        else
+          T.absurd(cmd)
+        end
+      end
+
+      sig { void }
+      def cancel
+        @stop_marking_finished = true
+      end
+
+      sig { returns T::Boolean }
+      def set_read_date_on_current_book
+        book = T.must(@current_book)
+        book_id = book.id
+        unless book_id
+          puts "#{Util::WARNING_EMOJI} Book #{book.title_and_author(stylize: true)} has no " \
+            "Storygraph ID, cannot set read date"
+          return false
+        end
+
+        finish_date = T.must(@current_finish_date)
+        success = @client.set_read_date(book_id, finish_date)
+
+        if success
+          book.finished_on = finish_date
+          book.save_to_database(@db_client.storygraph_books)
+          puts "#{Util::TAB}#{Util::SUCCESS_EMOJI} Done! #{book.url(stylize: true)}"
+        end
+
+        success
+      end
+
+      sig { void }
+      def skip_current_book
+        puts "#{Util::TAB}#{Util::INFO_EMOJI} Skipping..."
+        @current_book = nil
+        @current_finish_date = nil
+      end
+
+      sig { void }
+      def quit
+        puts "Goodbye!"
+        exit 0
+      end
+
+      sig { returns T::Hash[String, Date] }
+      def finish_dates_by_isbn
+        @finish_dates_by_isbn ||= @audible_library.finish_dates_by_isbn
+      end
+
+      sig { void }
+      def print_options
+        print_option(UserCommand::SetReadDate, "set read date to #{Util.pretty_date(T.must(@current_finish_date))}")
+        print_option(UserCommand::NextBook, "next book")
+        print_option(UserCommand::Cancel, "cancel")
+        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
+    end
+  end
+end

data/lib/good_audible_story_sync/storygraph.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module GoodAudibleStorySync
+  module Storygraph
+  end
+end
+
+require_relative "storygraph/auth"
+require_relative "storygraph/auth_flow"
+require_relative "storygraph/book"
+require_relative "storygraph/client"
+require_relative "storygraph/library"
+require_relative "storygraph/look_up_book_flow"
+require_relative "storygraph/mark_finished_flow"

data/lib/good_audible_story_sync/util/cipher.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# typed: true
+
+require "lockbox"
+require_relative "./keychain"
+
+module GoodAudibleStorySync
+  module Util
+    class Cipher
+      extend T::Sig
+
+      ENCRYPTION_KEY_NAME = "good_audible_story_sync_encryption_key"
+
+      sig { returns String }
+      def self.key
+        result = Keychain.load(name: ENCRYPTION_KEY_NAME)
+        if result.nil? || result.empty?
+          puts "#{INFO_EMOJI} No encryption key found in keychain. Generating a new one..."
+          result = Lockbox.generate_key
+          Keychain.save(name: ENCRYPTION_KEY_NAME, value: result)
+        else
+          puts "#{INFO_EMOJI} Using GoodAudibleStorySync encryption key from keychain"
+        end
+        result
+      end
+
+      sig { void }
+      def initialize
+        @lockbox = Lockbox.new(key: self.class.key)
+      end
+
+      sig { params(contents: String).returns(String) }
+      def encrypt(contents)
+        @lockbox.encrypt(contents)
+      end
+
+      sig { params(value: String).returns(String) }
+      def decrypt(value)
+        @lockbox.decrypt(value)
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/util/keychain.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+# typed: true
+# encoding: utf-8
+
+module GoodAudibleStorySync
+  module Util
+    class Keychain
+      extend T::Sig
+
+      LOCK_EMOJI = "🔐"
+
+      sig { params(name: String, value: String).void }
+      def self.save(name:, value:)
+        account_name = self.account_name
+        puts "#{LOCK_EMOJI} Saving '#{name}' to #{account_name}'s keychain..."
+        `security add-generic-password -s '#{name}' -a '#{account_name}' -w '#{value}'`
+      end
+
+      sig { params(name: String).returns(T.nilable(String)) }
+      def self.load(name:)
+        account_name = self.account_name
+        puts "#{LOCK_EMOJI} Looking for '#{name}' in #{account_name}'s keychain..."
+        `security find-generic-password -w -s '#{name}' -a '#{account_name}'`.strip
+      end
+
+      sig { returns String }
+      def self.account_name
+        `whoami`.strip
+      end
+    end
+  end
+end

data/lib/good_audible_story_sync/util.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+# typed: true
+# encoding: utf-8
+
+require "rainbow"
+
+module GoodAudibleStorySync
+  module Util
+    extend T::Sig
+
+    TAB = "  "
+    INFO_EMOJI = "ℹ️"
+    ERROR_EMOJI = "❌"
+    SAVE_EMOJI = "💾"
+    SUCCESS_EMOJI = "🟢"
+    DONE_EMOJI = "✅"
+    NEWLINE_EMOJI = "⮑"
+    WARNING_EMOJI = "🟡"
+
+    sig { params(words: T::Array[String]).returns(String) }
+    def self.join_words(words)
+      case words.size
+      when 0 then ""
+      when 1 then T.must(words[0])
+      when 2 then words.join(" and ")
+      else
+        head = T.must(words[0...-1]).join(", ")
+        tail = T.must(words[-1])
+        "#{head}, and #{tail}"
+      end
+    end
+
+    sig { params(words_str: String).returns(T::Array[String]) }
+    def self.split_words(words_str)
+      words_str.split(/, | and/).map { |word| word.strip.sub(/^and /, "") }
+    end
+
+    sig { params(timestamp: T.any(DateTime, Time)).returns(String) }
+    def self.pretty_time(timestamp)
+      # e.g., "Fri November 29, 2024 at 2:47am"
+      timestamp.strftime("%a %B %-d, %Y at %-l:%M%P")
+    end
+
+    sig { params(date: T.any(DateTime, Time, Date)).returns(String) }
+    def self.pretty_date(date)
+      # e.g., "Fri November 29, 2024"
+      date.strftime("%a %B %-d, %Y")
+    end
+
+    sig { params(str: T.nilable(String)).returns(T.nilable(String)) }
+    def self.squish(str)
+      return unless str
+      str.gsub(/[[:space:]]+/, " ").strip
+    end
+
+    sig { params(str: String).returns(T::Boolean) }
+    def self.integer?(str)
+      str.to_i.to_s == str
+    end
+
+    sig { params(str: String).returns(T::Boolean) }
+    def self.isbn?(str)
+      idx = str =~ /^(?=(?:\D*\d){10}(?:(?:\D*\d){3})?$)[\d-]+$/
+      idx == 0
+    end
+
+    sig { params(option: String, description: String).void }
+    def self.print_option(option, description)
+      desc_words = description.split(" ")
+      word_to_highlight = desc_words.detect { |word| word.downcase.start_with?(option) }
+      highlighted_word_index = desc_words.index(word_to_highlight)
+      highlighted_option = Rainbow(option).green
+      highlighted_word = if word_to_highlight
+        head = word_to_highlight.slice(0)
+        tail = word_to_highlight.slice(1..)
+        highlighted_head = Rainbow(head).green
+        "#{highlighted_head}#{tail}"
+      end
+      highlighted_description = if highlighted_word_index
+        head = (desc_words.slice(0, highlighted_word_index) || []).join(" ")
+        tail = (desc_words.slice(highlighted_word_index + 1..) || []).join(" ")
+        [head, highlighted_word, tail].compact.join(" ").strip
+      else
+        description
+      end
+      puts "#{highlighted_option}) #{highlighted_description}"
+    end
+  end
+end
+
+require_relative "util/cipher"
+require_relative "util/keychain"

data/lib/good_audible_story_sync/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module GoodAudibleStorySync
+  VERSION = "0.0.5"
+end

data/lib/good_audible_story_sync.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module GoodAudibleStorySync
+end
+
+require_relative "good_audible_story_sync/audible"
+require_relative "good_audible_story_sync/database"
+require_relative "good_audible_story_sync/goodreads"
+require_relative "good_audible_story_sync/input_loop"
+require_relative "good_audible_story_sync/options"
+require_relative "good_audible_story_sync/storygraph"
+require_relative "good_audible_story_sync/util"

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: good_audible_story_sync
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Sarah Vessels
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Interactive script to mark books as finished as well as set the finish
+  date on Storygraph, based on your Audible activity.
+email: cheshire137@gmail.com
+executables:
+- good-audible-story-sync
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/good-audible-story-sync
+- lib/good_audible_story_sync.rb
+- lib/good_audible_story_sync/audible.rb
+- lib/good_audible_story_sync/audible/auth.rb
+- lib/good_audible_story_sync/audible/auth_flow.rb
+- lib/good_audible_story_sync/audible/client.rb
+- lib/good_audible_story_sync/audible/library.rb
+- lib/good_audible_story_sync/audible/library_item.rb
+- lib/good_audible_story_sync/audible/user_profile.rb
+- lib/good_audible_story_sync/database.rb
+- lib/good_audible_story_sync/database/audible_books.rb
+- lib/good_audible_story_sync/database/client.rb
+- lib/good_audible_story_sync/database/credentials.rb
+- lib/good_audible_story_sync/database/goodreads_books.rb
+- lib/good_audible_story_sync/database/storygraph_books.rb
+- lib/good_audible_story_sync/database/sync_times.rb
+- lib/good_audible_story_sync/goodreads.rb
+- lib/good_audible_story_sync/goodreads/auth.rb
+- lib/good_audible_story_sync/goodreads/auth_flow.rb
+- lib/good_audible_story_sync/goodreads/book.rb
+- lib/good_audible_story_sync/goodreads/client.rb
+- lib/good_audible_story_sync/goodreads/library.rb
+- lib/good_audible_story_sync/input_loop.rb
+- lib/good_audible_story_sync/options.rb
+- lib/good_audible_story_sync/storygraph.rb
+- lib/good_audible_story_sync/storygraph/auth.rb
+- lib/good_audible_story_sync/storygraph/auth_flow.rb
+- lib/good_audible_story_sync/storygraph/book.rb
+- lib/good_audible_story_sync/storygraph/client.rb
+- lib/good_audible_story_sync/storygraph/library.rb
+- lib/good_audible_story_sync/storygraph/look_up_book_flow.rb
+- lib/good_audible_story_sync/storygraph/mark_finished_flow.rb
+- lib/good_audible_story_sync/util.rb
+- lib/good_audible_story_sync/util/cipher.rb
+- lib/good_audible_story_sync/util/keychain.rb
+- lib/good_audible_story_sync/version.rb
+homepage: https://github.com/cheshire137/good-audible-story-sync
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Command-line tool to sync your read books from Audible to Storygraph and,
+  eventually, Goodreads.
+test_files: []