anki_record 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 060b1e641776c8bf67bc20fa50029c1801ca7b367e2e038b2aa9b3024cd7b22b
-  data.tar.gz: 21a27f8b9d0726122bc2ba22eb6132573e161d30d73e4db866f081db87ea8409
+  metadata.gz: 4da2246d01a22eec129d18c242062ac1eb39b9b794129bf4666fc7eb2615087b
+  data.tar.gz: 5de4bdb4e80e078d8b5711466b2eba97b68563bfbb44f24805fc63b909a31d08
 SHA512:
-  metadata.gz: 8fdf8b0330814f95a11dffba1fbf2d113aa97269a8eba51d3675d7a8a761e37148dc5561b5fd96eeb9c94fd8b416ae00ade70acf88b20a0e5f7a9a668c4a8a7b
-  data.tar.gz: de6e49c1acbb6f56b952f682be94affaa8beecfcea79fb473fed9b53f0970e40394302b48a2b2cc167315589d8200669a13f5f4721ac184a4606b8a3ef4972f2
+  metadata.gz: ac4bb975b12ca50c5d9bba91caeec3accd75a952f04ae88a17ebef9b6b15cc7af335316ee024f1f50322ec77d321aad9106c6fac3a99eb657f48a1f513353c35
+  data.tar.gz: 62b7cbd1d173f23eb2c1a3b816a092f7cbd7200945ce8bea5aafa2d73dc59714f571f2869aadb62016749dbc2446d0f43cb16fc5d670f89ea8bc3507e2c2a2f0

data/.rubocop.yml

@@ -17,7 +17,9 @@ Layout/LineLength:
 
 Metrics/BlockLength:
   Exclude:
+    - "spec/*"
     - "spec/anki_record/*"
+    - "spec/integration/*"
 
 Layout/IndentationConsistency:
   EnforcedStyle: indented_internal_methods

data/CHANGELOG.md

@@ -1,16 +1,38 @@
 ## [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.

data/Gemfile

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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    anki_record (0.2.0)
+    anki_record (0.3.0)
       rubyzip (>= 2.3)
       sqlite3 (~> 1.3)
 
@@ -55,6 +55,8 @@ GEM
       parser (>= 3.1.1.0)
     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 +74,9 @@ DEPENDENCIES
   anki_record!
   pry
   rake (~> 13.0)
-  rdoc
   rspec (~> 3.0)
   rubocop (~> 1.21)
+  sdoc (~> 2.6)
   simplecov
 
 RUBY VERSION

data/README.md

@@ -1,8 +1,10 @@
-# 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.**
+Anki Record is a Ruby library which provides a programmatic interface to Anki flashcard decks/deck packages (`.apkg` files or Anki SQLite databases).
 
-[API Documentation](https://kylerego.github.io/anki_record_docs)
+**Development is ongoing and currently released versions may have some bugs. The library does not support media yet.**
+
+**To import the deck packages into Anki, click the File menu and then "Import" from inside Anki. Do not double click the `.apkg` file to open Anki and import it at the same time.**
 
 ## Installation
 
@@ -16,7 +18,7 @@ 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, it will execute the block, and afterwards zip an `*.apkg` file where `*` is the name argument (this argument is not allowed to contain spaces):
 
 ```ruby
 require "anki_record"
@@ -27,9 +29,12 @@ AnkiRecord::AnkiPackage.new(name: "test") do |apkg|
   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,39 +42,102 @@ Alternatively, if `AnkiRecord::Package::new` is not passed a block, the `zip` me
 require "anki_record"
 
 apkg = AnkiRecord::AnkiPackage.new(name: "test")
-apkg.zip
+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::Package.new` is `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"
+apkg = AnkiRecord::AnkiPackage.new(name: "test") do |apkg|
+  deck = apkg.collection.find_deck_by name: "Default"
+
+  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
 
-deck = apkg.collection.find_deck_by name: "Default"
+  note_type2 = apkg.collection.find_note_type_by name: "Cloze"
 
-note_type = apkg.collection.find_note_type_by name: "Basic"
+  note2 = AnkiRecord::Note.new note_type: note_type2, deck: deck
+  note2.text = "Cloze {{c1::Hello}}"
+  note2.back_extra = "World"
+  note2.save
+end
 
-note = AnkiRecord::Note.new note_type: note_type, deck: deck
-note.front = "Hello"
-note.back = "World"
-note.save
+```
 
-note_type2 = apkg.collection.find_note_type_by name: "Cloze"
+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.
 
-note2 = AnkiRecord::Note.new note_type: note_type2, deck: deck
-note2.text = "Cloze {{c1::Hello}}"
-note2.back_extra = "World"
-note2.save
+The next example shows some other features of the library:
+
+```ruby
+require "anki_record"
 
-apkg.zip
+note_id = nil
+
+AnkiRecord::AnkiPackage.new(name: "test_1") do |collection|
+  crazy_deck = AnkiRecord::Deck.new collection: collection, name: "test_1_deck"
+
+  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. The following is an example of output from one example in `spec/anki_record/note_spec.rb`:
+
+```
+AnkiRecord::Note
+  #save
+    for a note that does not exist in the collection.anki21 database (custom note type, 2 card templates)
+      should save two card records to the collection.anki21 database
+        with nid values equal to the id of the cards' note object's id
+```
 
-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` have a mapping with the source code in `lib`.
 
 ## Development
 
@@ -77,16 +145,31 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 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
@@ -103,4 +186,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,245 @@
+# 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.
+  #
+  # Here, Anki package refers to the zip file that Anki can export and import.
+  class AnkiPackage
+    include AnkiRecord::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(object_to_yield, &closure)
+        closure.call(object_to_yield)
+      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
+
+    ##
+    # Unzips the *.apkg file that was opened and yields its collection.anki21 database
+    # as a SQLite3::Database object (see sqlite3 gem) to the block.
+    #
+    # After the block executes, the files created by unzipping are deleted.
+    #
+    # Throws an error if the Anki package was not instantiated using ::open.
+    #
+    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 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
+
+    def open? # :nodoc:
+      !closed?
+    end
+
+    def closed? # :nodoc:
+      @anki21_database.closed?
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength