anki_record 0.3.1 → 0.4

data/lib/anki_record/anki_package/anki_package.rb

@@ -2,236 +2,170 @@
 
 require "pathname"
 
+require_relative "../anki2_database/anki2_database"
+require_relative "../anki21_database/anki21_database"
+require_relative "../media/media"
 require_relative "../card/card"
 require_relative "../collection/collection"
 require_relative "../note/note"
 require_relative "../database_setup_constants"
 
-# rubocop:disable Metrics/ClassLength
 module AnkiRecord
   ##
-  # AnkiPackage represents an Anki package deck file.
+  # AnkiPackage represents the Anki deck package file which has the .apkg file extension
+  #
+  # This is a zip file containing two SQLite databases (collection.anki21 and collection.anki2),
+  # a media file, and possibly the media (images and sound files). The gem currently does not
+  # have any support for adding or changing media in the Anki package.
   class AnkiPackage
-    include AnkiRecord::Helpers::DataQueryHelper
+    attr_accessor :anki21_database, :anki2_database, :media, :tmpdir, :tmpfiles, :target_directory, :name # :nodoc:
 
     ##
-    # The package's collection object.
-    attr_reader :collection
+    # Creates a new Anki package file (see the README)
+    def self.create(name:, target_directory: Dir.pwd, &closure)
+      anki_package = new
+      anki_package.create_initialize(name:, target_directory:, &closure)
+      anki_package
+    end
 
-    ##
-    # Instantiates a new Anki package object.
-    #
-    # See the README for usage details.
-    def initialize(name:, target_directory: Dir.pwd, data: nil, open_path: nil, &closure)
-      check_name_argument_is_valid(name:)
-      @name = name.end_with?(".apkg") ? name[0, name.length - 5] : name
+    def create_initialize(name:, target_directory: Dir.pwd, &closure) # :nodoc:
+      validate_arguments(name:, target_directory:)
+      @name = new_apkg_name(name:)
       @target_directory = target_directory
-      @open_path = open_path
-      check_directory_argument_is_valid
-      setup_other_package_instance_variables
-      insert_existing_data(data: data) if data
+      @tmpdir = Dir.mktmpdir
+      @tmpfiles = [Anki21Database::FILENAME, Anki2Database::FILENAME, Media::FILENAME]
+      @anki21_database = Anki21Database.create_new(anki_package: self)
+      @anki2_database = Anki2Database.create_new(anki_package: self)
+      @media = Media.create_new(anki_package: self)
 
-      execute_closure_and_zip(collection, &closure) if block_given?
+      execute_closure_and_zip(anki21_database, &closure) if closure
     end
 
-    # Returns an SQLite3::Statement object representing the given SQL and coupled to the collection.anki21 database.
-    #
-    # The Statement is executed using Statement#execute (see sqlite3 gem).
-    def prepare(sql)
-      @anki21_database.prepare sql
+    ##
+    # Opens an existing Anki package file to update its contents (see the README)
+    def self.update(path:, &closure)
+      anki_package = new
+      anki_package.update_initialize(path:, &closure)
+      anki_package
     end
 
-    private
-
-      def execute_closure_and_zip(collection, &closure)
-        closure.call(collection)
-      rescue StandardError => e
-        destroy_temporary_directory
-        puts_error_and_standard_message(error: e)
-      else
-        zip
-      end
-
-      def setup_other_package_instance_variables
-        @tmpdir = Dir.mktmpdir
-        @tmp_files = []
-        @anki21_database = setup_anki21_database_object
-        @anki2_database = setup_anki2_database_object
-        @media_file = setup_media
-        @collection = Collection.new(anki_package: self)
-      end
+    def update_initialize(path:, &closure) # :nodoc:
+      validate_path(path:)
 
-      def check_name_argument_is_valid(name:)
-        return if name.instance_of?(String) && !name.empty? && !name.include?(" ")
+      @tmpdir = Dir.mktmpdir
+      unzip_apkg_into_tmpdir(path:)
+      @tmpfiles = [Anki21Database::FILENAME, Anki2Database::FILENAME, Media::FILENAME]
+      @anki21_database = Anki21Database.update_new(anki_package: self)
+      @anki2_database = Anki2Database.update_new(anki_package: self)
+      @media = Media.update_new(anki_package: self)
 
-        raise ArgumentError, "The package name must be a string without spaces."
-      end
+      @updating_existing_apkg = true
+      execute_closure_and_zip(anki21_database, &closure) if closure
+    end
 
-      def check_directory_argument_is_valid
-        raise ArgumentError, "No directory was found at the given path." unless File.directory?(@target_directory)
-      end
+    # :nodoc:
+    def zip
+      @updating_existing_apkg ? replace_zip_file : create_zip_file
+      destroy_temporary_directory
+    end
 
-      def setup_anki21_database_object
-        anki21_file_name = "collection.anki21"
-        db = SQLite3::Database.new "#{@tmpdir}/#{anki21_file_name}", options: {}
-        @tmp_files << anki21_file_name
-        db.execute_batch ANKI_SCHEMA_DEFINITION
-        db.execute INSERT_COLLECTION_ANKI_21_COL_RECORD
-        db.results_as_hash = true
-        db
-      end
+    # :nocov:
+    def inspect
+      "[= AnkiPackage name: #{name} target_directory: #{target_directory} =]"
+    end
+    # :nocov:
 
-      def setup_anki2_database_object
-        anki2_file_name = "collection.anki2"
-        db = SQLite3::Database.new "#{@tmpdir}/#{anki2_file_name}", options: {}
-        @tmp_files << anki2_file_name
-        db.execute_batch ANKI_SCHEMA_DEFINITION
-        db.execute INSERT_COLLECTION_ANKI_2_COL_RECORD
-        db.close
-        db
-      end
+    private
 
-      def setup_media
-        media_file_path = FileUtils.touch("#{@tmpdir}/media")[0]
-        media_file = File.open(media_file_path, mode: "w")
-        media_file.write("{}")
-        media_file.close
-        @tmp_files << "media"
-        media_file
-      end
+      def validate_path(path:)
+        pathname = Pathname.new(path)
+        raise "*No .apkg file was found at the given path." unless pathname.file? && pathname.extname == ".apkg"
 
-      def insert_existing_data(data:)
-        @collection.copy_over_existing(col_record: data[:col_record])
-        copy_over_notes_and_cards(note_ids: data[:note_ids])
+        @name = File.basename(pathname.to_s, ".apkg")
+        @target_directory = pathname.expand_path.dirname.to_s
       end
 
-      def copy_over_notes_and_cards(note_ids:)
-        temporarily_unzip_source_apkg do |source_collection_anki21|
-          note_ids.each do |note_id|
-            note_cards_data = note_cards_data_for_note_id(sql_able: source_collection_anki21, id: note_id)
-            AnkiRecord::Note.new(collection: @collection, data: note_cards_data).save
+      def unzip_apkg_into_tmpdir(path:)
+        Zip::File.open(path) do |zip_file|
+          zip_file.each do |entry|
+            entry.extract("#{tmpdir}/#{entry.name}")
           end
         end
       end
 
-      def standard_error_thrown_in_block_message
-        "Any temporary files created have been deleted.\nNo new *.apkg zip file was saved."
+      def validate_arguments(name:, target_directory:)
+        check_name_argument_is_valid(name:)
+        check_target_directory_argument_is_valid(target_directory:)
       end
 
-      def puts_error_and_standard_message(error:)
-        puts error.backtrace
-        puts "#{error}\n#{standard_error_thrown_in_block_message}"
-      end
-
-    public
+      def check_name_argument_is_valid(name:)
+        return if name.instance_of?(String) && !name.empty? && !name.include?(" ")
 
-    ##
-    # Instantiates a new Anki package object seeded with data from the opened Anki package.
-    #
-    # See the README for details.
-    def self.open(path:, target_directory: nil, &closure)
-      pathname = Pathname.new(path)
-      raise "*No .apkg file was found at the given path." unless pathname.file? && pathname.extname == ".apkg"
-
-      new_apkg_name = "#{File.basename(pathname.to_s, ".apkg")}-#{seconds_since_epoch}"
-      data = col_record_and_note_ids_to_copy_over(pathname: pathname)
-
-      if target_directory
-        new(name: new_apkg_name, data: data, open_path: pathname,
-            target_directory: target_directory, &closure)
-      else
-        new(name: new_apkg_name, data: data, open_path: pathname, &closure)
+        raise ArgumentError, "The package name must be a string without spaces."
       end
-    end
-
-    def was_instantiated_from_existing_apkg? # :nodoc:
-      !@open_path.nil?
-    end
-
-    # rubocop:disable Metrics/MethodLength
-    # :nodoc:
-    def temporarily_unzip_source_apkg
-      raise ArgumentError unless @open_path && block_given?
 
-      Zip::File.open(@open_path) do |zip_file|
-        zip_file.each do |entry|
-          next unless entry.name == "collection.anki21"
+      def check_target_directory_argument_is_valid(target_directory:)
+        return if File.directory?(target_directory)
 
-          entry.extract
-          source_collection_anki21 = SQLite3::Database.open "collection.anki21"
-          source_collection_anki21.results_as_hash = true
-
-          yield source_collection_anki21
-        end
+        raise ArgumentError, "No directory was found at the given path."
       end
-      File.delete("collection.anki21")
-    end
-    # rubocop:enable Metrics/MethodLength
 
-    class << self
-      include Helpers::TimeHelper
+      def new_apkg_name(name:)
+        name.end_with?(".apkg") ? name[0, name.length - 5] : name
+      end
 
       # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Metrics/AbcSize
-      def col_record_and_note_ids_to_copy_over(pathname:) # :nodoc:
-        data = {}
-        Zip::File.open(pathname) do |zip_file|
-          zip_file.each do |entry|
-            next unless entry.name == "collection.anki21"
-
-            entry.extract
-            source_collection_anki21 = SQLite3::Database.open "collection.anki21"
-            source_collection_anki21.results_as_hash = true
-            col_record = source_collection_anki21.prepare("select * from col").execute.first
-            note_ids = source_collection_anki21.prepare("select id from notes").execute.map { |note| note["id"] }
-            data = { col_record: col_record, note_ids: note_ids }
-          end
-        end
-        File.delete("collection.anki21")
-        data
+      def execute_closure_and_zip(anki21_database)
+        yield(anki21_database)
+      rescue StandardError => e
+        destroy_temporary_directory
+        puts e.backtrace.reverse
+        puts e
+        puts "An error occurred within the block argument."
+        puts "The temporary files have been deleted."
+        puts "If you were creating a new Anki package, nothing was saved."
+        puts "If you were updating an existing one, it was not changed."
+      else
+        zip
       end
-      # rubocop:enable Metrics/AbcSize
       # rubocop:enable Metrics/MethodLength
-    end
-
-    ##
-    # Zips the temporary files (collection.anki21, collection.anki2, and media) into a new *.apkg package file.
-    #
-    # The temporary files, and the temporary directory they were in, are deleted after zipping.
-    def zip
-      create_zip_file && destroy_temporary_directory
-    end
 
-    private
+      def destroy_temporary_directory
+        FileUtils.rm_rf(tmpdir)
+      end
 
       def create_zip_file
         Zip::File.open(target_zip_file, create: true) do |zip_file|
-          @tmp_files.each do |file_name|
-            zip_file.add(file_name, File.join(@tmpdir, file_name))
+          tmpfiles.each do |file_name|
+            zip_file.add(file_name, File.join(tmpdir, file_name))
           end
         end
         true
       end
 
-      def target_zip_file
-        "#{@target_directory}/#{@name}.apkg"
+      # rubocop:disable Metrics/MethodLength
+      def replace_zip_file
+        File.rename(target_zip_file, tmp_original_zip_file)
+        begin
+          create_zip_file
+          FileUtils.rm(tmp_original_zip_file)
+        rescue StandardError => e
+          puts e.backtrace.reverse
+          puts e
+          puts "An error occurred during zipping the new version of the Anki package."
+          puts "The original package has not been changed"
+          File.rename(tmp_original_zip_file, target_zip_file)
+        end
+        true
       end
+      # rubocop:enable Metrics/MethodLength
 
-      def destroy_temporary_directory
-        FileUtils.rm_rf(@tmpdir)
+      def target_zip_file
+        "#{target_directory}/#{name}.apkg"
       end
 
-    public
-
-    # :nodoc:
-    def open?
-      !closed?
-    end
-
-    # :nodoc:
-    def closed?
-      @anki21_database.closed?
-    end
+      def tmp_original_zip_file
+        "#{target_zip_file}-old"
+      end
   end
 end
-# rubocop:enable Metrics/ClassLength

data/lib/anki_record/card/card.rb

@@ -6,39 +6,38 @@ require_relative "card_attributes"
 
 module AnkiRecord
   ##
-  # Card represents an Anki card.
+  # Card represents an Anki card. The cards are indirectly created when creating notes.
   class Card
     include CardAttributes
     include Helpers::TimeHelper
     include Helpers::SharedConstantsHelper
 
-    def initialize(note:, card_template: nil, card_data: nil) # :nodoc:
+    # :nodoc:
+
+    def initialize(note:, card_template: nil, card_data: nil)
       @note = note
       if card_template
-        setup_instance_variables_for_new_card(card_template: card_template)
+        setup_instance_variables_for_new_card(card_template:)
       elsif card_data
-        setup_instance_variables_from_existing(card_data: card_data)
+        setup_instance_variables_from_existing(card_data:)
       else
         raise ArgumentError
       end
     end
 
+    def save(note_exists_already: false)
+      note_exists_already ? update_card_in_collection_anki21 : insert_new_card_in_collection_anki21
+    end
+
     private
 
+      # rubocop:disable Metrics/MethodLength
       def setup_instance_variables_for_new_card(card_template:)
         raise ArgumentError unless @note.note_type == card_template.note_type
 
-        setup_collaborator_object_instance_variables_for_new_card(card_template: card_template)
-        setup_simple_instance_variables_for_new_card
-      end
-
-      def setup_collaborator_object_instance_variables_for_new_card(card_template:)
         @card_template = card_template
         @deck = @note.deck
-        @collection = @deck.collection
-      end
-
-      def setup_simple_instance_variables_for_new_card
+        @anki21_database = @deck.anki21_database
         @id = milliseconds_since_epoch
         @last_modified_timestamp = seconds_since_epoch
         @usn = NEW_OBJECT_USN
@@ -47,37 +46,22 @@ module AnkiRecord
         end
         @data = "{}"
       end
+      # rubocop:enable Metrics/MethodLength
 
       def setup_instance_variables_from_existing(card_data:)
-        setup_collaborator_object_instance_variables_from_existing(card_data: card_data)
-        setup_simple_instance_variables_from_existing(card_data: card_data)
-      end
-
-      def setup_collaborator_object_instance_variables_from_existing(card_data:)
-        @collection = note.note_type.collection
-        @deck = collection.find_deck_by id: card_data["did"]
+        @anki21_database = note.anki21_database
+        @deck = anki21_database.find_deck_by id: card_data["did"]
         @card_template = note.note_type.card_templates.find do |card_template|
           card_template.ordinal_number == card_data["ord"]
         end
-      end
-
-      def setup_simple_instance_variables_from_existing(card_data:)
         @last_modified_timestamp = card_data["mod"]
         %w[id usn type queue due ivl factor reps lapses left odue odid flags data].each do |instance_variable_name|
           instance_variable_set "@#{instance_variable_name}", card_data[instance_variable_name]
         end
       end
 
-    public
-
-    def save(note_exists_already: false) # :nodoc:
-      note_exists_already ? update_card_in_collection_anki21 : insert_new_card_in_collection_anki21
-    end
-
-    private
-
       def update_card_in_collection_anki21
-        statement = @collection.anki_package.prepare <<~SQL
+        statement = anki21_database.prepare <<~SQL
           update cards set nid = ?, did = ?, ord = ?, mod = ?, usn = ?, type = ?,
                             queue = ?, due = ?, ivl = ?, factor = ?, reps = ?, lapses = ?,
                             left = ?, odue = ?, odid = ?, flags = ?, data = ? where id = ?
@@ -89,7 +73,7 @@ module AnkiRecord
       end
 
       def insert_new_card_in_collection_anki21
-        statement = @collection.anki_package.prepare <<~SQL
+        statement = anki21_database.prepare <<~SQL
           insert into cards (id, nid, did, ord,
                             mod, usn, type, queue,
                             due, ivl, factor, reps,

data/lib/anki_record/card/card_attributes.rb

@@ -1,39 +1,8 @@
 # frozen_string_literal: true
 
 module AnkiRecord
-  ##
-  # Module with the Card class's attribute readers, writers, and accessors.
-  module CardAttributes
-    ##
-    # The card's note object.
-    attr_reader :note
-
-    ##
-    # The card's deck object.
-    attr_reader :deck
-
-    ##
-    # The card's collection object.
-    attr_reader :collection
-
-    ##
-    # The card's card template object.
-    attr_reader :card_template
-
-    ##
-    # The card's id.
-    #
-    # This is also the number of milliseconds since the 1970 epoch at which the card was created.
-    attr_reader :id
-
-    ##
-    # The number of seconds since the 1970 epoch at which the card was last modified.
-    attr_reader :last_modified_timestamp
-
-    ##
-    # The card's update sequence number.
-    attr_reader :usn
-
-    attr_reader :type, :queue, :due, :ivl, :factor, :reps, :lapses, :left, :odue, :odid, :flags, :data
+  module CardAttributes # :nodoc:
+    attr_reader :anki21_database, :note, :deck, :card_template, :id, :last_modified_timestamp, :usn, :type, :queue,
+                :due, :ivl, :factor, :reps, :lapses, :left, :odue, :odid, :flags, :data
   end
 end

data/lib/anki_record/card_template/card_template.rb

@@ -14,9 +14,9 @@ module AnkiRecord
 
       @note_type = note_type
       if args
-        setup_card_template_instance_variables_from_existing(args: args)
+        setup_card_template_instance_variables_from_existing(args:)
       else
-        setup_card_template_instance_variables(name: name)
+        setup_card_template_instance_variables(name:)
       end
 
       @note_type.add_card_template self

data/lib/anki_record/card_template/card_template_attributes.rb

@@ -5,25 +5,25 @@ module AnkiRecord
   # Module with the CardTemplate class's attribute readers, writers, and accessors.
   module CardTemplateAttributes
     ##
-    # The card template's name.
+    # The card template's name
     attr_accessor :name
 
     ##
-    # The card template's font style in the browser.
+    # The card template's font style in the browser
     attr_accessor :browser_font_style
 
     ##
-    # The card template's font size used in the browser.
+    # The card template's font size used in the browser
     attr_accessor :browser_font_size
 
     ##
-    # The card template's question format.
+    # The card template's question format
     attr_reader :question_format
 
     ##
-    # Sets the question format of the card template.
+    # Sets the question format of the card template
     #
-    # Raises an ArgumentError if the specified format attempts to use invalid fields.
+    # Raises an ArgumentError if the specified format attempts to use invalid fields
     def question_format=(format)
       fields_in_specified_format = format.scan(/{{.+?}}/).map do |capture|
         capture.chomp("}}").reverse.chomp("{{").reverse
@@ -38,13 +38,13 @@ module AnkiRecord
     end
 
     ##
-    # The card template's answer format.
+    # The card template's answer format
     attr_reader :answer_format
 
     ##
-    # Sets the answer format of the card template.
+    # Sets the answer format of the card template
     #
-    # Raises an ArgumentError if the specified format attempts to use invalid fields.
+    # Raises an ArgumentError if the specified format attempts to use invalid fields
     def answer_format=(format)
       fields_in_specified_format = format.scan(/{{.+?}}/).map do |capture|
         capture.chomp("}}").reverse.chomp("{{").reverse
@@ -59,11 +59,11 @@ module AnkiRecord
     end
 
     ##
-    # The card template's note type object.
+    # The card template's note type object
     attr_reader :note_type
 
     ##
-    # 0 for the first card template of the note type, 1 for the second, etc.
+    # 0 for the first card template of the note type, 1 for the second, etc
     attr_reader :ordinal_number
   end
 end