anki_record 0.3.2 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 909927e79a46b38b4a538e4fd0a32cf9a727ac0a9e276645fdd2296ad6d9a464
-  data.tar.gz: 2e75c487b6345606661d746b7d945b538592bbb6bed16b882a6ce42a87892368
+  metadata.gz: e1a86e3c0c6ba10ebfe3867e0bdc62d5a3e8e1218fc4783c1ade86c34d790318
+  data.tar.gz: 662ec96ab3e29c26b0de4405b1c699ba99a6b180af5dbb2a24eb6ad4e7919cef
 SHA512:
-  metadata.gz: aeb071caaf37a4fcd72c99f66e31b60676b412890883bf2968400bae46ac756433b0d051495a1ff34e477313ab8a296296e1fc1ecdf2b2227c241439712cef48
-  data.tar.gz: 36e4e21fa7238736ac63239e59507042e6567869add24d09523d201b1cf606738de055484e5c21ea7b37e05a1b5872a76c8241890ad32eaea611f56a8038cbc0
+  metadata.gz: 9d6de87dfadcc19fe0777202f67a97d632ddaec65426d171eda9ac74d87e7d99acc2afeb964e02529a695c1409a6c0fe26a9ee026d7b6fdbfb8c2d3b284230de
+  data.tar.gz: c35379873392e86fe7d6a402212d84c7c8d557543b84909d24c07e1ac34a927819628f13eff335f1b2a2e0d8bc7eda6218b86dca742660838d6b2148c16e4eee

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

@@ -45,4 +45,18 @@
 
 ## [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.
+- 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.
+
+## [0.4.1] - 08-21-2023
+- `Anki21Database#find_note_by` now can take the sort field value of a note as argument.
+- `Anki21Database#find_notes_by_exact_text_match` is a new method that returns an array of notes that have in any field text matching the argument.
+- Trying to create an Anki package file with a path/name that already exists raises a more helpful error message.
+- Saving a note to the database saves the `mod` column (last modified time) to make it easier to import an updated package into Anki.

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.2)
+    anki_record (0.4.1)
       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.2-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,31 @@ 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 most of the API:
 
 ```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 +48,93 @@ 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 new 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
+  # Finding the default deck
+  default_deck = anki21_database.find_deck_by(name: "Default")
+
+  # Finding 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 new 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 new 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
+# An example.apkg file should be in the current
+# working directory with 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.
+```ruby
+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.
 
-The RSpec test suite files in `spec` are organized similarly to the the source code in `lib`.
+## Documentation
 
-<!-- ## Development
+The [API Documentation](https://kylerego.github.io/anki_record_docs) generated from source code comments might be useful but I think the examples above show everything you can do that you would want to do.
+
+## 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,172 @@
+# 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
+
+    # rubocop:disable Metrics/MethodLength
+    ##
+    # Returns the note found by either +sfld" or +id+, or nil if it is not found.
+    def find_note_by(sfld: nil, id: nil)
+      if (id && sfld) || (id.nil? && sfld.nil?)
+        raise ArgumentError,
+              "You must pass either an id or sfld keyword argument to find_note_by."
+      end
+      note_cards_data = if id
+                          note_cards_data_for_note(id:)
+                        else
+                          note_cards_data_for_note(sfld:)
+                        end
+      return nil unless note_cards_data
+
+      AnkiRecord::Note.new(anki21_database: self, data: note_cards_data)
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    ##
+    # Returns an array of notes that have any field value matching +text+
+    def find_notes_by_exact_text_match(text:)
+      return [] if text == ""
+
+      like_matcher = "%#{text}%"
+      note_datas = prepare("select * from notes where flds LIKE ?").execute([like_matcher])
+
+      note_datas.map do |note_data|
+        id = note_data["id"]
+
+        cards_data = prepare("select * from cards where nid = ?").execute([id]).to_a
+        note_cards_data = { note_data:, cards_data: }
+
+        AnkiRecord::Note.new(anki21_database: self, data: note_cards_data)
+      end
+    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 to find_note_type_by."
+      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 to find_deck_by."
+      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: nil, sfld: nil)
+        note_data = if id
+                      prepare("select * from notes where id = ?").execute([id]).first
+                    elsif sfld
+                      prepare("select * from notes where sfld = ?").execute([sfld]).first
+                    end
+        return nil unless note_data
+
+        id ||= note_data["id"]
+
+        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