anki_record 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 060b1e641776c8bf67bc20fa50029c1801ca7b367e2e038b2aa9b3024cd7b22b
-  data.tar.gz: 21a27f8b9d0726122bc2ba22eb6132573e161d30d73e4db866f081db87ea8409
+  metadata.gz: b89baf921abc0de4f35babe65cb40cf5fa5647d4d1fe9b3b81ecb80f8a47a15b
+  data.tar.gz: f766e3344683a73d46450c8bf3cf6ae8226f4cbefee4d5126a194c6dcd831cab
 SHA512:
-  metadata.gz: 8fdf8b0330814f95a11dffba1fbf2d113aa97269a8eba51d3675d7a8a761e37148dc5561b5fd96eeb9c94fd8b416ae00ade70acf88b20a0e5f7a9a668c4a8a7b
-  data.tar.gz: de6e49c1acbb6f56b952f682be94affaa8beecfcea79fb473fed9b53f0970e40394302b48a2b2cc167315589d8200669a13f5f4721ac184a4606b8a3ef4972f2
+  metadata.gz: 3533d5803a630df54a2c52605fefc8f4dc4ce87e0a649a34672a7a3e369a53722f7d2481e9362388519eb89bd59fbfce8f7f226e0e489433e1d1a7d12fb285fd
+  data.tar.gz: 7b2ee79fd7ba76b1f229e06831909d3e4b7949c6edc79e608fdc2aae6fe481caa9ccf14c0cd586212b78ef1deddf9e47a91d505c30bd645cf4dae8282e3ff6a8

data/.rubocop.yml

@@ -1,3 +1,6 @@
+require:
+  - rubocop-rspec
+
 AllCops:
   TargetRubyVersion: 3.2.1
   NewCops: enable
@@ -12,12 +15,15 @@ Style/StringLiteralsInInterpolation:
 
 Layout/LineLength:
   Max: 120
+  # I like the rspec --format doc output to be very readable.
   Exclude:
-    - "spec/anki_record/*"
+    - "spec/anki_record/**/*"
 
 Metrics/BlockLength:
   Exclude:
+    - "spec/*"
     - "spec/anki_record/*"
+    - "bin/test_scripts/*"
 
 Layout/IndentationConsistency:
   EnforcedStyle: indented_internal_methods
@@ -26,4 +32,9 @@ Metrics/ClassLength:
   Max: 120
 
 Style/HashSyntax:
-  EnforcedShorthandSyntax: either
+  EnforcedShorthandSyntax: either
+
+# One expectation per test is a good practice. For this test suite,
+# following this rule would have a very high performance cost.
+RSpec/MultipleExpectations:
+  Enabled: false

data/CHANGELOG.md

@@ -1,16 +1,44 @@
 ## [Development started] - 02-02-2023
 
-## [Unreleased/0.1.0] - 02-22-2023
-
-- The gem can be used to create an *.apkg zip file that successfully imports into Anki.
-- Raw SQL statements can be executed against the temporary database before it is zipped.
-
 ## [0.1.1] - 02-24-2023
 
-- Updated documentation to release the first version
+- The initial version released.
+- The gem can create empty `.apkg` files that import into Anki.
+- SQL statements can be executed against the `collection.anki21` database before the zip file is created.
 
 ## [0.2.0] - 03-05-2023
 
-- `AnkiPackage#zip_and_close` is changed to `AnkiPackage#zip`
-- Decks and note types can be accessed through the collection object
-- Notes can be created, updated, and saved to the database and this also populates the corresponding records in the `cards` table
+- `AnkiPackage#zip_and_close` renamed to `AnkiPackage#zip`.
+- Decks and note types can be accessed with `Collection#find_deck_by` and `Collection#find_note_type_by`.
+- Note objects can be created and updated, and then saved to the `collection.anki21` database.
+  - This also populates corresponding records in the `cards` table.
+
+## [0.3.0] - 03-26-2023
+
+- `AnkiPackage::new` yields the collection object to the block instead of the Anki package object.
+- `AnkiPackage::open` has been developed to a point that it is useable.
+  - An "opened" Anki package now has its contents copied into the temporary `collection.anki21` database.
+- `AnkiPackage#execute` was removed.
+  - `AnkiPackage#prepare` was added. Any SQL statements executed directly against `collection.anki21` must now be prepared statements.
+- Custom decks (and nested decks/subdecks) and custom note types can be created and updated, and then saved to the `collection.anki21` database.
+- Notes can be accessed with `Collection#find_note_by`.
+- `Note#save` now updates a note (and its corresponding cards) if it was already in the `collection.anki21` database.
+- `Note::new` does not accept a `cloze` argument anymore; this attribute can be changed after instantiation with the `cloze=` setter.
+- `Deck` has a `deck_options_group` attribute instead of `deck_options_group_id`
+- `#inspect` added to `Deck`
+- Deck options groups can be accessed with `Collection#find_deck_options_group_by`
+- Multiple classes with `last_modified_time` and `creation_timestamp` attributes had these renamed to `last_modified_timestamp` and `created_at_timestamp`.
+- More helpful error messages in various places (e.g. "The package name must be a string without spaces.").
+- Bug fixes that may have affected previous version:
+  - Instantiating a note type from an existing Anki package no longer duplicates the note type when it is saved.
+  - Note types are not instantiated/saved with an invalid `req` value.
+    - In fixing this bug, other issues with `tags` and `vers` were introduced and then fixed.
+    - It was also noticed that the default note types with "Basic" in the name should not have `tags` and `vers` so this was changed too.
+- API documentation changed from using RDoc to SDoc with the Rails template.
+- RSpec test suite was refactored to improve speed: 4 minutes -> 1.5 minutes.
+
+## [0.4.0] - Not released
+
+- `Deck.new` was saving the deck to the `collection.anki21` database. Now it will only instantiate it and `#save` must be called to save it.
+- `Helper` modules moved into the `Helpers` module namespace.
+- Bug fix addressing using the approximate milliseconds since the epoch as the primary key id causing the uniqueness constraint to fail when creating a lot of notes.

data/Gemfile

@@ -17,4 +17,6 @@ gem "rubocop", "~> 1.21"
 
 gem "pry"
 
-gem "rdoc"
+gem "sdoc", "~> 2.6"
+
+gem "rubocop-rspec", "~> 2.20"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    anki_record (0.2.0)
+    anki_record (0.3.1)
       rubyzip (>= 2.3)
       sqlite3 (~> 1.3)
 
@@ -53,8 +53,15 @@ GEM
       unicode-display_width (>= 2.4.0, < 3.0)
     rubocop-ast (1.24.1)
       parser (>= 3.1.1.0)
+    rubocop-capybara (2.17.1)
+      rubocop (~> 1.41)
+    rubocop-rspec (2.20.0)
+      rubocop (~> 1.33)
+      rubocop-capybara (~> 2.17)
     ruby-progressbar (1.11.0)
     rubyzip (2.3.2)
+    sdoc (2.6.1)
+      rdoc (>= 5.0)
     simplecov (0.22.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
@@ -72,9 +79,10 @@ DEPENDENCIES
   anki_record!
   pry
   rake (~> 13.0)
-  rdoc
   rspec (~> 3.0)
   rubocop (~> 1.21)
+  rubocop-rspec (~> 2.20)
+  sdoc (~> 2.6)
   simplecov
 
 RUBY VERSION

data/README.md

@@ -1,8 +1,6 @@
-# AnkiRecord
+# Anki Record
 
-AnkiRecord is a Ruby gem which provides a programmatic interface to creating and updating Anki flashcard deck files (`*.apkg` Anki SQLite databases). **This gem is in an early stage of development--I do not recommend you use it yet.**
-
-[API Documentation](https://kylerego.github.io/anki_record_docs)
+Anki Record is a Ruby gem providing an API to Anki flashcard deck packages (zipped SQLite databases). The main thing it does not support yet is adding media to the notes.
 
 ## Installation
 
@@ -16,20 +14,23 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-The Anki package object is instantiated with `AnkiRecord::AnkiPackage.new` and if passed a block, will execute the block and zip the `*.apkg` file:
+The Anki package object is instantiated with `AnkiRecord::AnkiPackage.new`. If this is passed a block, the collection object is yielded to the block, and an Anki deck package file is created after execution of the block:
 
 ```ruby
 require "anki_record"
 
-AnkiRecord::AnkiPackage.new(name: "test") do |apkg|
+AnkiRecord::AnkiPackage.new(name: "test") do |collection|
   3.times do |number|
     puts "#{3 - number}..."
   end
   puts "Countdown complete. Write any Ruby you want in here!"
 end
+# test.apkg now exists in the current working directory.
 ```
 
-If an exception is raised inside the block, the temporary `collection.anki2` and `collection.anki21` databases are deleted without creating a new `*.apkg` zip file, so this is the recommended way.
+While execution is happening inside the block, temporary `collection.anki21` and `collection.anki2` SQLite databases and a `media` file exist inside of a temporary directory. These files are the normal zipped contents of an `*.apkg` file. `collection.anki21` is the database that the library is interacting with.
+
+If an exception is raised inside the block, the files are deleted without creating a new `*.apkg` zip file, so this is the recommended way.
 
 Alternatively, if `AnkiRecord::Package::new` is not passed a block, the `zip` method must be explicitly called on the Anki package object:
 
@@ -37,61 +38,145 @@ Alternatively, if `AnkiRecord::Package::new` is not passed a block, the `zip` me
 require "anki_record"
 
 apkg = AnkiRecord::AnkiPackage.new(name: "test")
-apkg.zip
+collection = apkg.collection
+# Add notes to the collection
+apkg.zip # This zips the temporary files into test.apkg, and then deletes them.
 ```
 
-A new Anki package object is initialized with the "Default" deck and the default note types of a new Anki collection (including "Basic" and "Cloze"). The deck and note type objects can be accessed through the `collection` attribute of the Anki package object through the `find_deck_by` and `find_note_type_by` methods by passing the `name` keyword argument:
+The second, optional argument to `AnkiRecord::AnkiPackage.new` is `target_directory`. The default value is the current working directory, but if a relative file path argument is given, the new `*.apkg` file will be saved in that directory. An exception will be raised if the relative file path is not to a directory that exists.
+
+A new Anki package object is initialized with the "Default" deck and the default note types of a new Anki collection (including "Basic" and "Cloze"). The deck and note type objects are accessed through the `collection` attribute of the Anki package object through the `find_deck_by` and `find_note_type_by` methods passed the `name` keyword argument:
 
 ```ruby
 require "anki_record"
 
-apkg = AnkiRecord::AnkiPackage.new name: "test"
+AnkiRecord::AnkiPackage.new(name: "test") do |collection|
+  deck = collection.find_deck_by name: "Default"
 
-deck = apkg.collection.find_deck_by name: "Default"
+  note_type = collection.find_note_type_by name: "Basic"
 
-note_type = apkg.collection.find_note_type_by name: "Basic"
+  note = AnkiRecord::Note.new note_type: note_type, deck: deck
+  note.front = "Hello"
+  note.back = "World"
+  note.save
 
-note = AnkiRecord::Note.new note_type: note_type, deck: deck
-note.front = "Hello"
-note.back = "World"
-note.save
+  note_type2 = collection.find_note_type_by name: "Cloze"
 
-note_type2 = apkg.collection.find_note_type_by name: "Cloze"
+  note2 = AnkiRecord::Note.new note_type: note_type2, deck: deck
+  note2.text = "Cloze {{c1::Hello}}"
+  note2.back_extra = "World"
+  note2.save
+end
 
-note2 = AnkiRecord::Note.new note_type: note_type2, deck: deck
-note2.text = "Cloze {{c1::Hello}}"
-note2.back_extra = "World"
-note2.save
+```
 
-apkg.zip
+This example creates a `test.apkg` zip file in the current working directory, which when imported into Anki, will add one Basic note and one Cloze note.
 
+The next example shows some other features of the library:
+
+```ruby
+require "anki_record"
+
+note_id = nil
+
+AnkiRecord::AnkiPackage.new(name: "test_1") do |collection|
+  crazy_deck = AnkiRecord::Deck.new collection: collection, name: "test_1_deck"
+  crazy_deck.save
+
+  crazy_note_type = AnkiRecord::NoteType.new collection: collection, name: "test 1 note type"
+  AnkiRecord::NoteField.new note_type: crazy_note_type, name: "crazy front"
+  AnkiRecord::NoteField.new note_type: crazy_note_type, name: "crazy back"
+  crazy_card_template = AnkiRecord::CardTemplate.new note_type: crazy_note_type, name: "test 1 card 1"
+  crazy_card_template.question_format = "{{crazy front}}"
+  crazy_card_template.answer_format = "{{crazy back}}"
+  second_crazy_card_template = AnkiRecord::CardTemplate.new note_type: crazy_note_type, name: "test 1 card 2"
+  second_crazy_card_template.question_format = "{{crazy back}}"
+  second_crazy_card_template.answer_format = "{{crazy front}}"
+
+  css = <<~CSS
+    .card {
+      font-size: 16px;
+      font-style: Verdana;
+      background: transparent;
+      text-align: center;
+    }
+  CSS
+
+  crazy_note_type.css = css
+  crazy_note_type.save
+
+  note = AnkiRecord::Note.new note_type: crazy_note_type, deck: crazy_deck
+  note.crazy_front = "Hello from test 1"
+  note.crazy_back = "World"
+  note.save
+
+  note_id = note.id
+end
+
+AnkiRecord::AnkiPackage.open(path: "./test_1.apkg") do |collection|
+  note = collection.find_note_by id: note_id
+  note.crazy_back = "Ruby"
+  note.save
+end
 ```
 
-This example creates a `test.apkg` zip file in the current working directory, which when imported into Anki, will add one Basic note and one Cloze note.
+This script creates an Anki package `test_1.apkg` with a new deck and new note type, and one note in that deck using that type. It then opens that Anki package, and edits the note. Note that the `test_1.apkg` file is not changed by this. Instead, a new package with a name similar to `test_1-1679835468.apkg` is created (the number is a timestamp).
+
+## Documentation
+
+The [API Documentation](https://kylerego.github.io/anki_record_docs) is generated using SDoc from comments in the source code. You might notice that some public methods are intentionally omitted from this documentation. Although public, these methods are not intended to be used outside of the gem's implementation and should be treated as private.
+
+The RSpec examples are intended to provide executable documentation and may also be helpful to understand the API. Running the test suite with the `rspec` command will output these in a more readable way that also reflects the nesting of the RSpec examples and example groups. This is an example of part of the output:
+
+```
+AnkiRecord::Deck#save
+  when the deck does not exist in the collection.anki21 database
+    saves the deck object's id as a key in the decks column's JSON object in the collection.anki21 database
+    saves the deck object as a hash, as the value of the deck object's id key, in the decks hash
+    saves the deck object as a hash with the following keys: 'id', 'mod', 'name', 'usn', 'lrnToday', 'revToday', 'newToday', 'timeToday', 'collapsed', 'browserCollapsed', 'desc', 'dyn', 'conf', 'extendNew', 'extendRev'
+    saves the deck object as a hash with the deck object's id attribute as the value for the id key in the deck hash
+    saves the deck object as a hash with the deck object's last_modified_timestamp attribute as the value for the mod key in the deck hash
+
+```
 
-The RSpec examples are intended to provide executable documentation, and reading them may be helpful to understand the API (e.g. [anki_package_spec.rb](https://github.com/KyleRego/anki_record/blob/main/spec/anki_record/anki_package_spec.rb)).
+The RSpec test suite files in `spec` are organized similarly to the the source code in `lib`.
 
-## Development
+<!-- ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
-### Development road map: 
-- Work on creating and updating notes and cards to the collection.anki21 database
-- Validation logic of what makes the note valid based on the note type's card templates and fields
-- Work on adding media support
-  - Checksum for notes needs to be updated
-- Work on updating and saving decks
-- Work on updating and saving deck options groups
-- Work on updating and saving note types including the note fields and card templates
+### Development road map:
+- Better messages when `ArgumentError` raised
+- Add #inspect methods
+- Refactor tests to improve speed
+- Copying the contents of an existing package into the new package when it is opened
+    - Add more unit tests
+- Work on creating, updating, and saving notes and cards to the collection.anki21 database
+    - Updating notes when they already exist in the database
+        - Add more unit tests
+    - Validation logic of what makes the note valid based on the note type's card templates and fields
+    - Work on adding media support
+      - The checksum calculation for notes will need to be updated to account for HTML in the content
+- Saving note types, decks, and deck options groups to the collection.anki21 database
+    - Deck options groups cannot be saved yet.
+    - Add being able to handle subdecks
+    - Updating them when they already exist
+    - Setters for any relevant attributes with validation
+- Refactoring
+    - Use more specific RSpec matchers than `eq` everywhere
+    - Investigate if note guid is determined in Anki in a non-random way
+    - Investigate if the database ever needs to be explicitly opened or closed
+- Note type allowed fields: investigate if there are other special field names that should be allowed.
 
 ### Release checklist
+- Remove `require "pry"`
 - Update changelog
 - Update usage examples
 - Update and regenerate documentation
 - Bump version
-- Release gem
+- Release gem -->
 
 <!-- ## Contributing
 
@@ -103,4 +188,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the AnkiRecord project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/KyleRego/anki_record/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the Anki Record project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/KyleRego/anki_record/blob/main/CODE_OF_CONDUCT.md).

data/anki_record.gemspec

@@ -10,13 +10,12 @@ Gem::Specification.new do |spec|
 
   spec.summary = "Automate Anki flashcard editing with the Ruby programming language."
   spec.description = <<-DESC
-  This Ruby library, which is currently in development, will provide an interface to inspect, update, and create Anki SQLite3 databases (*.apkg files).
+  A Ruby library which provides a programmatic interface to Anki flashcard decks (.apkg files/zipped Anki SQLite databases).
   DESC
   spec.homepage = "https://github.com/KyleRego/anki_record"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 3.2.1"
 
-  # spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
   spec.metadata["rubygems_mfa_required"] = "true"
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/KyleRego/anki_record"
@@ -35,7 +34,4 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "rubyzip", ">= 2.3"
   spec.add_dependency "sqlite3", "~> 1.3"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
 end

data/lib/anki_record/anki_package/anki_package.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+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.
+  class AnkiPackage
+    include AnkiRecord::Helpers::DataQueryHelper
+
+    ##
+    # The package's collection object.
+    attr_reader :collection
+
+    ##
+    # 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
+      @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
+
+      execute_closure_and_zip(collection, &closure) if block_given?
+    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
+    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 check_name_argument_is_valid(name:)
+        return if name.instance_of?(String) && !name.empty? && !name.include?(" ")
+
+        raise ArgumentError, "The package name must be a string without spaces."
+      end
+
+      def check_directory_argument_is_valid
+        raise ArgumentError, "No directory was found at the given path." unless File.directory?(@target_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
+
+      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
+
+      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 insert_existing_data(data:)
+        @collection.copy_over_existing(col_record: data[:col_record])
+        copy_over_notes_and_cards(note_ids: data[:note_ids])
+      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
+          end
+        end
+      end
+
+      def standard_error_thrown_in_block_message
+        "Any temporary files created have been deleted.\nNo new *.apkg zip file was saved."
+      end
+
+      def puts_error_and_standard_message(error:)
+        puts error.backtrace
+        puts "#{error}\n#{standard_error_thrown_in_block_message}"
+      end
+
+    public
+
+    ##
+    # 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)
+      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"
+
+          entry.extract
+          source_collection_anki21 = SQLite3::Database.open "collection.anki21"
+          source_collection_anki21.results_as_hash = true
+
+          yield source_collection_anki21
+        end
+      end
+      File.delete("collection.anki21")
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    class << self
+      include Helpers::TimeHelper
+
+      # 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
+      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 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))
+          end
+        end
+        true
+      end
+
+      def target_zip_file
+        "#{@target_directory}/#{@name}.apkg"
+      end
+
+      def destroy_temporary_directory
+        FileUtils.rm_rf(@tmpdir)
+      end
+
+    public
+
+    # :nodoc:
+    def open?
+      !closed?
+    end
+
+    # :nodoc:
+    def closed?
+      @anki21_database.closed?
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength