git-pkgs 0.5.0 → 0.6.0

data/lib/git/pkgs/database.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
-require "active_record"
-require "sqlite3"
+require "sequel"
+
+# Set up a placeholder DB so models can be defined before connection
+DB = Sequel.sqlite
+Sequel::Model.plugin :timestamps, update_on_create: true
+Sequel::Model.plugin :update_or_create
+Sequel::Model.require_valid_table = false
+Sequel::Model.unrestrict_primary_key
+# Allow mass assignment of any column (similar to AR default behavior)
+Sequel::Model.strict_param_setting = false
 
 module Git
   module Pkgs
@@ -9,6 +17,10 @@ module Git
       DB_FILE = "pkgs.sqlite3"
       SCHEMA_VERSION = 1
 
+      class << self
+        attr_accessor :db
+      end
+
       def self.path(git_dir = nil)
         return Git::Pkgs.db_path if Git::Pkgs.db_path
 
@@ -23,7 +35,6 @@ module Git
           raise NotInGitRepoError, "GIT_DIR '#{Git::Pkgs.git_dir}' does not exist"
         end
 
-        # Start from work_tree if set, otherwise current directory
         dir = Git::Pkgs.work_tree || Dir.pwd
         loop do
           git_dir = File.join(dir, ".git")
@@ -37,20 +48,54 @@ module Git
       end
 
       def self.connect(git_dir = nil, check_version: true)
+        disconnect
         db_path = path(git_dir)
-        ActiveRecord::Base.establish_connection(
-          adapter: "sqlite3",
-          database: db_path
-        )
+        @db = Sequel.sqlite(db_path)
+        Sequel::Model.db = @db
+        refresh_models
         check_version! if check_version
+        @db
       end
 
       def self.connect_memory
-        ActiveRecord::Base.establish_connection(
-          adapter: "sqlite3",
-          database: ":memory:"
-        )
+        disconnect
+        @db = Sequel.sqlite
+        Sequel::Model.db = @db
+        refresh_models
         create_schema
+        @db
+      end
+
+      def self.disconnect
+        return unless @db
+
+        Sequel::DATABASES.delete(@db)
+        @db.disconnect rescue nil
+        @db = nil
+      end
+
+      def self.refresh_models
+        # Force models to use the new database connection
+        [
+          Git::Pkgs::Models::Branch,
+          Git::Pkgs::Models::BranchCommit,
+          Git::Pkgs::Models::Commit,
+          Git::Pkgs::Models::Manifest,
+          Git::Pkgs::Models::DependencyChange,
+          Git::Pkgs::Models::DependencySnapshot
+        ].each do |model|
+          model.dataset = @db[model.table_name]
+          # Clear cached association datasets and loaders that may reference old db
+          model.association_reflections.each_value do |reflection|
+            if reflection[:cache]
+              reflection[:cache].delete(:_dataset)
+              reflection[:cache].delete(:associated_eager_dataset)
+              reflection[:cache].delete(:placeholder_eager_loader)
+            end
+          end
+        rescue Sequel::Error
+          # Table may not exist yet
+        end
       end
 
       def self.exists?(git_dir = nil)
@@ -58,111 +103,110 @@ module Git
       end
 
       def self.create_schema(with_indexes: true)
-        ActiveRecord::Schema.verbose = false
-        ActiveRecord::Schema.define do
-          create_table :schema_info, if_not_exists: true do |t|
-            t.integer :version, null: false
-          end
+        @db.create_table?(:schema_info) do
+          Integer :version, null: false
+        end
 
-          create_table :branches, if_not_exists: true do |t|
-            t.string :name, null: false
-            t.string :last_analyzed_sha
-            t.timestamps
-          end
-          add_index :branches, :name, unique: true, if_not_exists: true
-
-          create_table :commits, if_not_exists: true do |t|
-            t.string :sha, null: false
-            t.text :message
-            t.string :author_name
-            t.string :author_email
-            t.datetime :committed_at
-            t.boolean :has_dependency_changes, default: false
-            t.timestamps
-          end
-          add_index :commits, :sha, unique: true, if_not_exists: true
+        @db.create_table?(:branches) do
+          primary_key :id
+          String :name, null: false
+          String :last_analyzed_sha
+          DateTime :created_at
+          DateTime :updated_at
+          index :name, unique: true
+        end
 
-          create_table :branch_commits, if_not_exists: true do |t|
-            t.references :branch, foreign_key: true
-            t.references :commit, foreign_key: true
-            t.integer :position
-          end
-          add_index :branch_commits, [:branch_id, :commit_id], unique: true, if_not_exists: true
+        @db.create_table?(:commits) do
+          primary_key :id
+          String :sha, null: false
+          String :message, text: true
+          String :author_name
+          String :author_email
+          DateTime :committed_at
+          TrueClass :has_dependency_changes, default: false
+          DateTime :created_at
+          DateTime :updated_at
+          index :sha, unique: true
+        end
 
-          create_table :manifests, if_not_exists: true do |t|
-            t.string :path, null: false
-            t.string :ecosystem
-            t.string :kind
-            t.timestamps
-          end
-          add_index :manifests, :path, if_not_exists: true
-
-          create_table :dependency_changes, if_not_exists: true do |t|
-            t.references :commit, foreign_key: true
-            t.references :manifest, foreign_key: true
-            t.string :name, null: false
-            t.string :ecosystem
-            t.string :change_type, null: false
-            t.string :requirement
-            t.string :previous_requirement
-            t.string :dependency_type
-            t.timestamps
-          end
+        @db.create_table?(:branch_commits) do
+          primary_key :id
+          foreign_key :branch_id, :branches
+          foreign_key :commit_id, :commits
+          Integer :position
+          index [:branch_id, :commit_id], unique: true
+        end
 
-          create_table :dependency_snapshots, if_not_exists: true do |t|
-            t.references :commit, foreign_key: true
-            t.references :manifest, foreign_key: true
-            t.string :name, null: false
-            t.string :ecosystem
-            t.string :requirement
-            t.string :dependency_type
-            t.timestamps
-          end
+        @db.create_table?(:manifests) do
+          primary_key :id
+          String :path, null: false
+          String :ecosystem
+          String :kind
+          DateTime :created_at
+          DateTime :updated_at
+          index :path
+        end
+
+        @db.create_table?(:dependency_changes) do
+          primary_key :id
+          foreign_key :commit_id, :commits
+          foreign_key :manifest_id, :manifests
+          String :name, null: false
+          String :ecosystem
+          String :change_type, null: false
+          String :requirement
+          String :previous_requirement
+          String :dependency_type
+          DateTime :created_at
+          DateTime :updated_at
+        end
+
+        @db.create_table?(:dependency_snapshots) do
+          primary_key :id
+          foreign_key :commit_id, :commits
+          foreign_key :manifest_id, :manifests
+          String :name, null: false
+          String :ecosystem
+          String :requirement
+          String :dependency_type
+          DateTime :created_at
+          DateTime :updated_at
         end
 
         set_version
         create_bulk_indexes if with_indexes
+        refresh_models
       end
 
       def self.create_bulk_indexes
-        conn = ActiveRecord::Base.connection
-
-        # dependency_changes indexes
-        conn.add_index :dependency_changes, :name, if_not_exists: true
-        conn.add_index :dependency_changes, :ecosystem, if_not_exists: true
-        conn.add_index :dependency_changes, [:commit_id, :name], if_not_exists: true
+        @db.alter_table(:dependency_changes) do
+          add_index :name, if_not_exists: true
+          add_index :ecosystem, if_not_exists: true
+          add_index [:commit_id, :name], if_not_exists: true
+        end
 
-        # dependency_snapshots indexes
-        conn.add_index :dependency_snapshots, [:commit_id, :manifest_id, :name],
-                       unique: true, name: "idx_snapshots_unique", if_not_exists: true
-        conn.add_index :dependency_snapshots, :name, if_not_exists: true
-        conn.add_index :dependency_snapshots, :ecosystem, if_not_exists: true
+        @db.alter_table(:dependency_snapshots) do
+          add_index [:commit_id, :manifest_id, :name], unique: true, name: "idx_snapshots_unique", if_not_exists: true
+          add_index :name, if_not_exists: true
+          add_index :ecosystem, if_not_exists: true
+        end
       end
 
       def self.stored_version
-        conn = ActiveRecord::Base.connection
-        return nil unless conn.table_exists?(:schema_info)
+        return nil unless @db.table_exists?(:schema_info)
 
-        result = conn.select_value("SELECT version FROM schema_info LIMIT 1")
-        result&.to_i
+        @db[:schema_info].get(:version)
       end
 
       def self.set_version(version = SCHEMA_VERSION)
-        conn = ActiveRecord::Base.connection
-        conn.execute("DELETE FROM schema_info")
-        conn.execute("INSERT INTO schema_info (version) VALUES (#{version})")
+        @db[:schema_info].delete
+        @db[:schema_info].insert(version: version)
       end
 
       def self.needs_upgrade?
-        conn = ActiveRecord::Base.connection
-
-        # No tables at all = fresh database, no upgrade needed
-        return false unless conn.table_exists?(:commits)
-
-        # Has commits table but no schema_info = old database, needs upgrade
-        return true unless conn.table_exists?(:schema_info)
+        return false unless @db.table_exists?(:commits)
+        return true unless @db.table_exists?(:schema_info)
 
-        # Check version
         stored = stored_version || 0
         stored < SCHEMA_VERSION
       end
@@ -177,19 +221,18 @@ module Git
       end
 
       def self.optimize_for_bulk_writes
-        conn = ActiveRecord::Base.connection
-        conn.execute("PRAGMA synchronous = OFF")
-        conn.execute("PRAGMA journal_mode = WAL")
-        conn.execute("PRAGMA cache_size = -64000") # 64MB cache
+        @db.run("PRAGMA synchronous = OFF")
+        @db.run("PRAGMA journal_mode = WAL")
+        @db.run("PRAGMA cache_size = -64000")
       end
 
       def self.optimize_for_reads
-        conn = ActiveRecord::Base.connection
-        conn.execute("PRAGMA synchronous = NORMAL")
+        @db.run("PRAGMA synchronous = NORMAL")
       end
 
       def self.drop(git_dir = nil)
-        ActiveRecord::Base.connection.close if ActiveRecord::Base.connected?
+        @db&.disconnect
+        @db = nil
         File.delete(path(git_dir)) if exists?(git_dir)
       end
     end

data/lib/git/pkgs/models/branch.rb

@@ -3,14 +3,12 @@
 module Git
   module Pkgs
     module Models
-      class Branch < ActiveRecord::Base
-        has_many :branch_commits, dependent: :destroy
-        has_many :commits, through: :branch_commits
-
-        validates :name, presence: true, uniqueness: true
+      class Branch < Sequel::Model
+        one_to_many :branch_commits
+        many_to_many :commits, join_table: :branch_commits
 
         def self.find_or_create(name)
-          find_or_create_by(name: name)
+          first(name: name) || create(name: name)
         end
       end
     end

data/lib/git/pkgs/models/branch_commit.rb

@@ -3,11 +3,9 @@
 module Git
   module Pkgs
     module Models
-      class BranchCommit < ActiveRecord::Base
-        belongs_to :branch
-        belongs_to :commit
-
-        validates :branch_id, uniqueness: { scope: :commit_id }
+      class BranchCommit < Sequel::Model
+        many_to_one :branch
+        many_to_one :commit
       end
     end
   end

data/lib/git/pkgs/models/commit.rb

@@ -3,16 +3,17 @@
 module Git
   module Pkgs
     module Models
-      class Commit < ActiveRecord::Base
-        has_many :branch_commits, dependent: :destroy
-        has_many :branches, through: :branch_commits
-        has_many :dependency_changes, dependent: :destroy
-        has_many :dependency_snapshots, dependent: :destroy
+      class Commit < Sequel::Model
+        unrestrict_primary_key
+        plugin :validation_helpers
 
-        validates :sha, presence: true, uniqueness: true
+        one_to_many :branch_commits
+        one_to_many :dependency_changes
+        one_to_many :dependency_snapshots
+        many_to_many :branches, join_table: :branch_commits
 
         def self.find_or_create_from_rugged(rugged_commit)
-          find_or_create_by(sha: rugged_commit.oid) do |commit|
+          find_or_create(sha: rugged_commit.oid) do |commit|
             commit.message = rugged_commit.message&.strip
             commit.author_name = rugged_commit.author[:name]
             commit.author_email = rugged_commit.author[:email]
@@ -21,13 +22,13 @@ module Git
         end
 
         def self.find_or_create_from_repo(repo, sha)
-          commit = find_by(sha: sha) || where("sha LIKE ?", "#{sha}%").first
+          commit = first(sha: sha) || where(Sequel.like(:sha, "#{sha}%")).first
           return commit if commit
 
           rugged_commit = repo.lookup(sha)
           return nil unless rugged_commit
 
-          create!(
+          create(
             sha: rugged_commit.oid,
             message: rugged_commit.message,
             author_name: rugged_commit.author[:name],

data/lib/git/pkgs/models/dependency_change.rb

@@ -3,18 +3,31 @@
 module Git
   module Pkgs
     module Models
-      class DependencyChange < ActiveRecord::Base
-        belongs_to :commit
-        belongs_to :manifest
+      class DependencyChange < Sequel::Model
+        many_to_one :commit
+        many_to_one :manifest
 
-        validates :name, presence: true
-        validates :change_type, presence: true, inclusion: { in: %w[added modified removed] }
+        dataset_module do
+          def added
+            where(change_type: "added")
+          end
 
-        scope :added, -> { where(change_type: "added") }
-        scope :modified, -> { where(change_type: "modified") }
-        scope :removed, -> { where(change_type: "removed") }
-        scope :for_package, ->(name) { where(name: name) }
-        scope :for_platform, ->(platform) { where(ecosystem: platform) }
+          def modified
+            where(change_type: "modified")
+          end
+
+          def removed
+            where(change_type: "removed")
+          end
+
+          def for_package(name)
+            where(name: name)
+          end
+
+          def for_platform(platform)
+            where(ecosystem: platform)
+          end
+        end
       end
     end
   end

data/lib/git/pkgs/models/dependency_snapshot.rb

@@ -3,21 +3,29 @@
 module Git
   module Pkgs
     module Models
-      class DependencySnapshot < ActiveRecord::Base
-        belongs_to :commit
-        belongs_to :manifest
+      class DependencySnapshot < Sequel::Model
+        many_to_one :commit
+        many_to_one :manifest
 
-        validates :name, presence: true
+        dataset_module do
+          def for_package(name)
+            where(name: name)
+          end
 
-        scope :for_package, ->(name) { where(name: name) }
-        scope :for_platform, ->(platform) { where(ecosystem: platform) }
-        scope :at_commit, ->(commit) { where(commit: commit) }
+          def for_platform(platform)
+            where(ecosystem: platform)
+          end
+
+          def at_commit(commit)
+            where(commit: commit)
+          end
+        end
 
         def self.current_for_branch(branch)
-          return none unless branch.last_analyzed_sha
+          return dataset.where(false) unless branch.last_analyzed_sha
 
-          commit = Commit.find_by(sha: branch.last_analyzed_sha)
-          return none unless commit
+          commit = Commit.first(sha: branch.last_analyzed_sha)
+          return dataset.where(false) unless commit
 
           where(commit: commit)
         end

data/lib/git/pkgs/models/manifest.rb

@@ -3,17 +3,15 @@
 module Git
   module Pkgs
     module Models
-      class Manifest < ActiveRecord::Base
-        has_many :dependency_changes, dependent: :destroy
-        has_many :dependency_snapshots, dependent: :destroy
+      class Manifest < Sequel::Model
+        one_to_many :dependency_changes
+        one_to_many :dependency_snapshots
 
-        validates :path, presence: true
+        def self.find_or_create(path:, ecosystem: nil, kind: nil)
+          existing = first(path: path)
+          return existing if existing
 
-        def self.find_or_create(path:, ecosystem:, kind:)
-          find_or_create_by(path: path) do |m|
-            m.ecosystem = ecosystem
-            m.kind = kind
-          end
+          create(path: path, ecosystem: ecosystem, kind: kind)
         end
       end
     end

data/lib/git/pkgs/version.rb

@@ -2,6 +2,6 @@
 
 module Git
   module Pkgs
-    VERSION = "0.5.0"
+    VERSION = "0.6.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-pkgs
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Andrew Nesbitt
@@ -24,19 +24,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: sequel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -55,16 +55,16 @@ dependencies:
   name: ecosystems-bibliothecary
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '15.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '15.0'
 description: A git subcommand for analyzing package/dependency usage in git repositories
   over time
 email: