anki_record 0.3.1 → 0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b89baf921abc0de4f35babe65cb40cf5fa5647d4d1fe9b3b81ecb80f8a47a15b
-  data.tar.gz: f766e3344683a73d46450c8bf3cf6ae8226f4cbefee4d5126a194c6dcd831cab
+  metadata.gz: 625337f0aac620a6662e846e1bf08a4ebe7a57224386b7154e24381ff275a507
+  data.tar.gz: cb8e0001a1b37ad480ef3b218a1e64ef1a7429da777bb7f7bd9b68b51d2cbd9a
 SHA512:
-  metadata.gz: 3533d5803a630df54a2c52605fefc8f4dc4ce87e0a649a34672a7a3e369a53722f7d2481e9362388519eb89bd59fbfce8f7f226e0e489433e1d1a7d12fb285fd
-  data.tar.gz: 7b2ee79fd7ba76b1f229e06831909d3e4b7949c6edc79e608fdc2aae6fe481caa9ccf14c0cd586212b78ef1deddf9e47a91d505c30bd645cf4dae8282e3ff6a8
+  metadata.gz: c0e0fbf06f373cf555bd233c6f42aff0123858f80e58b5a525ca72f53bec28572930c91988424b9c3a3756182f779177a92c4f6dc8d8eae86cb46a95d3216ae1
+  data.tar.gz: e89bc47239ad32052e9b51f1825073bc1dd40e8586b56360437fac0dbf7258fd8b6e7eb4d9f7f5a4b4dee8b00f66482fccf3b99aa03a024c83c636a54a4c5e0a

data/.rspec

@@ -1,3 +1,2 @@
---format documentation
 --color
 --require spec_helper

data/.rubocop.yml

@@ -1,5 +1,7 @@
 require:
   - rubocop-rspec
+  - rubocop-rake
+  - rubocop-performance
 
 AllCops:
   TargetRubyVersion: 3.2.1
@@ -9,10 +11,6 @@ Style/StringLiterals:
   Enabled: true
   EnforcedStyle: double_quotes
 
-Style/StringLiteralsInInterpolation:
-  Enabled: true
-  EnforcedStyle: double_quotes
-
 Layout/LineLength:
   Max: 120
   # I like the rspec --format doc output to be very readable.
@@ -31,9 +29,6 @@ Layout/IndentationConsistency:
 Metrics/ClassLength:
   Max: 120
 
-Style/HashSyntax:
-  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:

data/CHANGELOG.md

@@ -37,8 +37,20 @@
 - 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
+## [0.3.1] - 04-29-2023
 
 - `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.
+
+## [0.3.2] - 05-20-2023
+- The private `Note` method `globally_unique_id` has been moved to `NoteGuidHelper` and included into note.
+- The `guid` attribute also now has a public setter.
+
+## [0.4] - 07-08-2023
+- `AnkiPackage.new` and `AnkiPackage.open` have been removed and replaced with `AnkiPackage.create` and `AnkiPackage.update`.
+- `AnkiPackage.update` is different from `AnkiPackage.open` in that it does not create a new Anki package with a timestamp. It effectively updates the original Anki package file as long as no error is thrown. 
+- `Anki21Database` is yielded to the block of the above methods instead of `Collection`.
+- Responsibilites of `Collection` have been reorganized to `Anki21Database`.
+- The `guid` attribute of notes ic computed in a different way that allows a larger number of possible values.
+- `globally_unique_id` is now a module method rather than an included instance method.

data/Gemfile

@@ -20,3 +20,7 @@ gem "pry"
 gem "sdoc", "~> 2.6"
 
 gem "rubocop-rspec", "~> 2.20"
+
+gem "rubocop-rake", "~> 0.6.0"
+
+gem "rubocop-performance", "~> 1.18"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    anki_record (0.3.1)
+    anki_record (0.4)
       rubyzip (>= 2.3)
       sqlite3 (~> 1.3)
 
@@ -55,6 +55,11 @@ GEM
       parser (>= 3.1.1.0)
     rubocop-capybara (2.17.1)
       rubocop (~> 1.41)
+    rubocop-performance (1.18.0)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
     rubocop-rspec (2.20.0)
       rubocop (~> 1.33)
       rubocop-capybara (~> 2.17)
@@ -68,7 +73,7 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
-    sqlite3 (1.6.0-x86_64-linux)
+    sqlite3 (1.6.3-x86_64-linux)
     stringio (3.0.5)
     unicode-display_width (2.4.2)
 
@@ -81,6 +86,8 @@ DEPENDENCIES
   rake (~> 13.0)
   rspec (~> 3.0)
   rubocop (~> 1.21)
+  rubocop-performance (~> 1.18)
+  rubocop-rake (~> 0.6.0)
   rubocop-rspec (~> 2.20)
   sdoc (~> 2.6)
   simplecov

data/README.md

@@ -1,6 +1,6 @@
 # Anki Record
 
-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.
+Anki Record is a Ruby gem to create and update Anki flashcard deck packages (files with the .apkg extension). It does not support adding media yet.
 
 ## Installation
 
@@ -14,84 +14,26 @@ 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`. 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:
+This example shows how to create a new Anki package and also most of the features of the gem:
 
-```ruby
-require "anki_record"
-
-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.
-```
-
-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:
-
-```ruby
-require "anki_record"
-
-apkg = AnkiRecord::AnkiPackage.new(name: "test")
-collection = apkg.collection
-# Add notes to the collection
-apkg.zip # This zips the temporary files into test.apkg, and then deletes them.
 ```
-
-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"
 
-AnkiRecord::AnkiPackage.new(name: "test") do |collection|
-  deck = collection.find_deck_by name: "Default"
-
-  note_type = 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_type2 = 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
-
-```
-
-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}}"
+AnkiRecord::AnkiPackage.create(name: "example") do |anki21_database|
+  # Creating a new deck
+  custom_deck = AnkiRecord::Deck.new(anki21_database:, name: "New custom deck")
+  custom_deck.save
+
+  # Creating a new note type
+  custom_note_type = AnkiRecord::NoteType.new(anki21_database:, name: "New custom note type")
+  AnkiRecord::NoteField.new(note_type: custom_note_type, name: "custom front")
+  AnkiRecord::NoteField.new(note_type: custom_note_type, name: "custom back")
+  custom_card_template = AnkiRecord::CardTemplate.new(note_type: custom_note_type, name: "Custom template 1")
+  custom_card_template.question_format = "{{custom front}}"
+  custom_card_template.answer_format = "{{custom back}}"
+  second_custom_card_template = AnkiRecord::CardTemplate.new(note_type: custom_note_type, name: "Custom template 2")
+  second_custom_card_template.question_format = "{{custom back}}"
+  second_custom_card_template.answer_format = "{{custom front}}"
 
   css = <<~CSS
     .card {
@@ -101,83 +43,88 @@ AnkiRecord::AnkiPackage.new(name: "test_1") do |collection|
       text-align: center;
     }
   CSS
+  custom_note_type.css = css
+  custom_note_type.save
 
-  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"
+  # Creating a note with the custom note type
+  note = AnkiRecord::Note.new(note_type: custom_note_type, deck: custom_deck)
+  note.custom_front = "Content of the 'custom front' field"
+  note.custom_back = "Content of the 'custom back' field"
   note.save
 
-  note_id = note.id
+  # The default deck
+  default_deck = anki21_database.find_deck_by(name: "Default")
+
+  # All of the default Anki note types
+  basic_note_type = anki21_database.find_note_type_by(name: "Basic")
+  basic_and_reversed_card_note_type = anki21_database.find_note_type_by(name: "Basic (and reversed card)")
+  basic_and_optional_reversed_card_note_type = anki21_database.find_note_type_by(name: "Basic (optional reversed card)")
+  basic_type_in_the_answer_note_type = anki21_database.find_note_type_by(name: "Basic (type in the answer)")
+  cloze_note_type = anki21_database.find_note_type_by(name: "Cloze")
+
+  # Creating notes using the default note types
+
+  basic_note = AnkiRecord::Note.new(note_type: basic_note_type, deck: default_deck)
+  basic_note.front = "What molecule is most relevant to the name aerobic exercise?"
+  basic_note.back = "Oxygen"
+  basic_note.save
+
+  # Creating a nested deck
+  amino_acids_deck = AnkiRecord::Deck.new(anki21_database:, name: "Biochemistry::Amino acids")
+  amino_acids_deck.save
+
+  basic_and_reversed_note = AnkiRecord::Note.new(note_type: basic_and_reversed_card_note_type, deck: amino_acids_deck)
+  basic_and_reversed_note.front = "Tyrosine"
+  basic_and_reversed_note.back = "Y"
+  basic_and_reversed_note.save
+
+  basic_and_optional_reversed_note = AnkiRecord::Note.new(note_type: basic_and_optional_reversed_card_note_type, deck: default_deck)
+  basic_and_optional_reversed_note.front = "A technique where locations along a route are memorized and associated with ideas"
+  basic_and_optional_reversed_note.back = "The method of loci"
+  basic_and_optional_reversed_note.add_reverse = "Have a reverse card too"
+  basic_and_optional_reversed_note.save
+
+  basic_type_in_the_answer_note = AnkiRecord::Note.new(note_type: basic_type_in_the_answer_note_type, deck: default_deck)
+  basic_type_in_the_answer_note.front = "What Git command commits staged changes by changing the previous commit without editing the commit message?"
+  basic_type_in_the_answer_note.back = "git commit --amend --no-edit"
+  basic_type_in_the_answer_note.save
+
+  cloze_note = AnkiRecord::Note.new(note_type: cloze_note_type, deck: default_deck)
+  cloze_note.text = "Dysfunction of CN {{c1::VII}} occurs in Bell's palsy"
+  cloze_note.back_extra = "This condition involves one cranial nerve but can have myriad neurological symptoms"
+  cloze_note.save
 end
+# The example.apkg package now exists in the current working directory and contains 6 notes.
 
-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 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).
+`AnkiRecord::AnkiPackage.new` can also take a `target_directory` keyword argument to specify the directory to save the Anki package. If an error is thrown inside the block argument, temporary files that exist during execution of the block (Anki SQLite databases and the file called `media`) are deleted and no new Anki package is created.
 
-## Documentation
+The gem can also be used to update an existing Anki package:
 
-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.
+```
+require "anki_record"
 
-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::AnkiPackage.update(path: "./example.apkg") do |anki21_database|
+  amino_acids_deck = anki21_database.find_deck_by(name: "Biochemistry::Amino acids")
+  custom_note_type = anki21_database.find_note_type_by(name: "New custom note type")
 
+  # Create more decks, note types, notes etc. There are not many methods that would be useful here for finding and updating notes yet.
+end
 ```
-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
 
-```
+If an error is thrown in the block here, the original Anki package will not be changed.
+
+## Documentation
 
-The RSpec test suite files in `spec` are organized similarly to the the source code in `lib`.
+The [API Documentation](https://kylerego.github.io/anki_record_docs) is generated from comments in the source code could be useful if the above examples are not sufficient for your use case.
 
-<!-- ## 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:
-- 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 -->
-
 <!-- ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/KyleRego/anki_record. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/KyleRego/anki_record/blob/master/CODE_OF_CONDUCT.md). -->

data/anki_record.gemspec

@@ -8,9 +8,9 @@ Gem::Specification.new do |spec|
   spec.authors = ["Kyle Rego"]
   spec.email = ["regoky@outlook.com"]
 
-  spec.summary = "Automate Anki flashcard editing with the Ruby programming language."
+  spec.summary = "Create and update Anki deck packages with Ruby."
   spec.description = <<-DESC
-  A Ruby library which provides a programmatic interface to Anki flashcard decks (.apkg files/zipped Anki SQLite databases).
+  Anki Record lets you create Anki deck packages or update existing ones with the Ruby programming language.
   DESC
   spec.homepage = "https://github.com/KyleRego/anki_record"
   spec.license = "MIT"

data/lib/anki_record/anki21_database/anki21_database.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "anki21_database_attributes"
+require_relative "anki21_database_constructors"
+
+module AnkiRecord
+  ##
+  # Anki21Database represents the collection.anki21 Anki SQLite database in the Anki Package
+  class Anki21Database
+    include Anki21DatabaseAttributes
+    include Anki21DatabaseConstructors
+
+    def self.create_new(anki_package:) # :nodoc:
+      anki21_database = new
+      anki21_database.create_initialize(anki_package:)
+      anki21_database
+    end
+
+    def self.update_new(anki_package:) # :nodoc:
+      anki21_database = new
+      anki21_database.update_initialize(anki_package:)
+      anki21_database
+    end
+
+    ##
+    # Returns an SQLite3::Statement object (sqlite3 gem) to be executed against the collection.anki21 database.
+    #
+    # Statement#execute executes the statement.
+    def prepare(sql)
+      database.prepare sql
+    end
+
+    ##
+    # Returns the note found by +id+, or nil if it is not found.
+    def find_note_by(id:)
+      note_cards_data = note_cards_data_for_note_id(id:)
+      return nil unless note_cards_data
+
+      AnkiRecord::Note.new(anki21_database: self, data: note_cards_data)
+    end
+
+    ##
+    # Returns the note type found by either +name+ or +id+, or nil if it is not found.
+    def find_note_type_by(name: nil, id: nil)
+      if (id && name) || (id.nil? && name.nil?)
+        raise ArgumentError,
+              "You must pass either an id or name keyword argument."
+      end
+
+      name ? find_note_type_by_name(name:) : find_note_type_by_id(id:)
+    end
+
+    ##
+    # Returns the deck found by either +name+ or +id+, or nil if it is not found.
+    def find_deck_by(name: nil, id: nil)
+      if (id && name) || (id.nil? && name.nil?)
+        raise ArgumentError,
+              "You must pass either an id or name keyword argument."
+      end
+
+      name ? find_deck_by_name(name:) : find_deck_by_id(id:)
+    end
+
+    ##
+    # Returns the deck options group object found by +id+, or nil if it is not found.
+    def find_deck_options_group_by(id:)
+      deck_options_groups.find { |deck_options_group| deck_options_group.id == id }
+    end
+
+    def decks_json # :nodoc:
+      JSON.parse(prepare("select decks from col;").execute.first["decks"])
+    end
+
+    def models_json # :nodoc:
+      JSON.parse(prepare("select models from col;").execute.first["models"])
+    end
+
+    def col_record # :nodoc:
+      prepare("select * from col").execute.first
+    end
+
+    def add_note_type(note_type) # :nodoc:
+      raise ArgumentError unless note_type.instance_of?(AnkiRecord::NoteType)
+
+      existing_note_type = nil
+      note_types.each do |nt|
+        existing_note_type = nt if nt.id == note_type.id
+      end
+      note_types.delete(existing_note_type) if existing_note_type
+
+      note_types << note_type
+    end
+
+    def add_deck(deck) # :nodoc:
+      raise ArgumentError unless deck.instance_of?(AnkiRecord::Deck)
+
+      decks << deck
+    end
+
+    def add_deck_options_group(deck_options_group) # :nodoc:
+      raise ArgumentError unless deck_options_group.instance_of?(AnkiRecord::DeckOptionsGroup)
+
+      deck_options_groups << deck_options_group
+    end
+
+    # :nocov:
+    def inspect # :nodoc:
+      "[= Anki21Database of package with name #{package.name} =]"
+    end
+    # :nocov:
+
+    private
+
+      def find_note_type_by_name(name:)
+        note_types.find { |note_type| note_type.name == name }
+      end
+
+      def find_note_type_by_id(id:)
+        note_types.find { |note_type| note_type.id == id }
+      end
+
+      def find_deck_by_name(name:)
+        decks.find { |deck| deck.name == name }
+      end
+
+      def find_deck_by_id(id:)
+        decks.find { |deck| deck.id == id }
+      end
+
+      def note_cards_data_for_note_id(id:)
+        note_data = prepare("select * from notes where id = ?").execute([id]).first
+        return nil unless note_data
+
+        cards_data = prepare("select * from cards where nid = ?").execute([id]).to_a
+        { note_data:, cards_data: }
+      end
+  end
+end

data/lib/anki_record/anki21_database/anki21_database_attributes.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module AnkiRecord
+  ##
+  # Module with Anki21Database's attribute readers, writers, and accessors
+  module Anki21DatabaseAttributes
+    ##
+    # The database's note types as an array
+    attr_reader :note_types
+
+    ##
+    # The database's decks as an array
+    attr_reader :decks
+
+    ##
+    # The database's deck option groups as an array
+    attr_reader :deck_options_groups
+
+    ##
+    # The database's parent Anki package
+    attr_reader :anki_package
+
+    ##
+    # The database's collection record
+    attr_reader :collection
+
+    ##
+    # The database's collection.anki21 SQLite3::Database
+    attr_reader :database
+  end
+end

data/lib/anki_record/anki21_database/anki21_database_constructors.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module AnkiRecord
+  module Anki21DatabaseConstructors # :nodoc:
+    FILENAME = "collection.anki21"
+
+    def create_initialize(anki_package:)
+      @anki_package = anki_package
+      @database = SQLite3::Database.new "#{anki_package.tmpdir}/#{FILENAME}", options: {}
+      database.execute_batch ANKI_SCHEMA_DEFINITION
+      database.execute INSERT_COLLECTION_ANKI_21_COL_RECORD
+      database.results_as_hash = true
+      @collection = Collection.new(anki21_database: self)
+      initialize_note_types
+      initialize_deck_options_groups
+      initialize_decks
+    end
+
+    def update_initialize(anki_package:)
+      @anki_package = anki_package
+      @database = SQLite3::Database.new("#{anki_package.tmpdir}/#{FILENAME}", options: {})
+      database.results_as_hash = true
+      @collection = Collection.new(anki21_database: self)
+      initialize_note_types
+      initialize_deck_options_groups
+      initialize_decks
+    end
+
+    private
+
+      def initialize_note_types
+        @note_types = []
+        JSON.parse(col_record["models"]).values.map do |model_hash|
+          NoteType.new(anki21_database: self, args: model_hash)
+        end
+      end
+
+      def initialize_decks
+        @decks = []
+        JSON.parse(col_record["decks"]).values.map do |deck_hash|
+          Deck.new(anki21_database: self, args: deck_hash)
+        end
+      end
+
+      def initialize_deck_options_groups
+        @deck_options_groups = []
+        JSON.parse(col_record["dconf"]).values.map do |dconf_hash|
+          DeckOptionsGroup.new(anki21_database: self, args: dconf_hash)
+        end
+      end
+  end
+end

data/lib/anki_record/anki2_database/anki2_database.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module AnkiRecord
+  ##
+  # Anki2Database represents the collection.anki2 Anki SQLite database in the Anki Package
+  #
+  # This is not the database targeted by the Anki Record gem but it is part of the Anki
+  # package zip file.
+  class Anki2Database
+    FILENAME = "collection.anki2"
+
+    # :nodoc:
+
+    attr_reader :anki_package, :database
+
+    def self.create_new(anki_package:)
+      anki2_database = new
+      anki2_database.create_initialize(anki_package:)
+      anki2_database
+    end
+
+    def create_initialize(anki_package:)
+      @anki_package = anki_package
+      @database = SQLite3::Database.new("#{anki_package.tmpdir}/#{FILENAME}", options: {})
+      database.execute_batch(ANKI_SCHEMA_DEFINITION)
+      database.execute(INSERT_COLLECTION_ANKI_2_COL_RECORD)
+      database.close
+      database
+    end
+
+    def self.update_new(anki_package:)
+      anki2_database = new
+      anki2_database.update_initialize(anki_package:)
+      anki2_database
+    end
+
+    def update_initialize(anki_package:)
+      @anki_package = anki_package
+      @database = SQLite3::Database.new("#{anki_package.tmpdir}/#{FILENAME}", options: {})
+      database.close
+      database
+    end
+  end
+end