gemvault 0.1.1

data/lib/bundler/plugin/vault_source.rb

@@ -0,0 +1,117 @@
+require "fileutils"
+require_relative "../../gemvault/vault"
+
+module Bundler
+  module Plugin
+    class VaultSource
+      def initialize(opts)
+        super
+        @vault_path = resolve_vault_path(@uri)
+        validate_vault_exists!
+      end
+
+      def fetch_gemspec_files
+        gemspec_files = []
+
+        Gemvault::Vault.open(@vault_path) do |vault|
+          vault.gem_entries.each do |entry|
+            spec = vault.spec_from_blob(entry.name, entry.version, entry.platform)
+            full_name = spec.full_name
+            spec_ruby = spec.to_ruby
+
+            gem_dir = gem_dir_for(full_name)
+            if File.directory?(gem_dir)
+              gemspec_files << anchor_gemspec(gem_dir, full_name, spec_ruby)
+            else
+              gemspec_dir = File.join(Bundler.tmp("vault_source"), "specifications")
+              FileUtils.mkdir_p(gemspec_dir)
+              gemspec_path = File.join(gemspec_dir, "#{full_name}.gemspec")
+              File.write(gemspec_path, spec_ruby)
+              gemspec_files << gemspec_path
+            end
+          end
+        end
+
+        gemspec_files
+      end
+
+      def install(spec, opts = {})
+        gem_dir = gem_dir_for(spec.full_name)
+        if File.directory?(gem_dir) && !opts[:force]
+          Bundler.ui.debug "Using #{version_message(spec)} from vault #{File.basename(@vault_path)}"
+          gemspec_in_gem = File.join(gem_dir, "#{spec.full_name}.gemspec")
+          spec.full_gem_path = gem_dir
+          spec.loaded_from = gemspec_in_gem
+          return nil
+        end
+
+        Bundler.ui.confirm "Installing #{version_message(spec)} from vault #{File.basename(@vault_path)}"
+
+        Gemvault::Vault.open(@vault_path) do |vault|
+          vault.with_gem_file(spec.name, spec.version.to_s, platform: spec.platform.to_s) do |gem_path|
+            require "bundler/rubygems_gem_installer"
+
+            installer = Bundler::RubyGemsGemInstaller.at(
+              gem_path,
+              install_dir: Bundler.bundle_path.to_s,
+              bin_dir: Bundler.system_bindir.to_s,
+              ignore_dependencies: true,
+              wrappers: true,
+              env_shebang: true,
+              build_args: opts[:build_args] || [],
+            )
+
+            installed_spec = installer.install
+
+            gem_dir = installed_spec.full_gem_path
+            spec.full_gem_path = gem_dir
+            spec.loaded_from = anchor_gemspec(gem_dir, spec.full_name, installed_spec.to_ruby)
+          end
+        end
+
+        spec.post_install_message
+      end
+
+      def options_to_lock
+        {}
+      end
+
+      def to_s
+        "vault at #{@uri}"
+      end
+
+      private
+
+      def version_message(spec)
+        message = "#{spec.name} #{spec.version}"
+        message += " (#{spec.platform})" if spec.platform != Gem::Platform::RUBY && !spec.platform.nil?
+        message
+      end
+
+      def resolve_vault_path(uri)
+        File.expand_path(uri, Bundler.root.to_s)
+      end
+
+      # Bundler computes full_gem_path as dirname(loaded_from) for plugin
+      # sources, so the gemspec must live inside the gem directory -- not
+      # in specifications/ -- for load paths to resolve correctly.
+      def anchor_gemspec(gem_dir, full_name, spec_ruby)
+        gemspec_path = File.join(gem_dir, "#{full_name}.gemspec")
+        File.write(gemspec_path, spec_ruby) unless File.exist?(gemspec_path)
+        gemspec_path
+      end
+
+      def gem_dir_for(full_name)
+        File.join(Bundler.bundle_path, "gems", full_name)
+      end
+
+      def validate_vault_exists!
+        return if File.file?(@vault_path)
+
+        raise Bundler::PathError,
+              "Could not find vault '#{@uri}' referenced in Gemfile " \
+              "(relative to #{Bundler.root})"
+      end
+    end
+  end
+end

data/lib/gemvault/cli/command.rb

@@ -0,0 +1,17 @@
+require "command_kit/command"
+require_relative "../vault"
+
+module Gemvault
+  class CLI
+    class Command < CommandKit::Command
+      private
+
+      def with_vault(path, create: false, &block)
+        Gemvault::Vault.open(path, create: create, &block)
+      rescue Gemvault::Vault::Error => e
+        print_error(e.message)
+        exit(1)
+      end
+    end
+  end
+end

data/lib/gemvault/cli/commands/add.rb

@@ -0,0 +1,30 @@
+require_relative "../command"
+
+module Gemvault
+  class CLI
+    module Commands
+      class Add < Command
+        description "Add gem files to a vault"
+
+        argument :vault, required: true,
+                         usage: "VAULT",
+                         desc: "Vault file"
+
+        argument :gems, required: true,
+                        repeats: true,
+                        usage: "GEM",
+                        desc: "Gem files to add"
+
+        def run(vault, *gems)
+          with_vault(vault) do |v|
+            gems.each do |gem_path|
+              v.add(gem_path)
+              spec = Gem::Package.new(gem_path).spec
+              puts "Added #{spec.name}-#{spec.version}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gemvault/cli/commands/extract.rb

@@ -0,0 +1,49 @@
+require "fileutils"
+require_relative "../command"
+
+module Gemvault
+  class CLI
+    module Commands
+      class Extract < Command
+        description "Extract gem file(s) from a vault"
+
+        argument :vault, required: true,
+                         usage: "VAULT",
+                         desc: "Vault file"
+
+        argument :name, required: true,
+                        usage: "NAME",
+                        desc: "Gem name"
+
+        argument :version, required: false,
+                           usage: "VERSION",
+                           desc: "Gem version (omit to extract all versions)"
+
+        option :output, short: "-o",
+                        value: { type: String, default: "." },
+                        desc: "Output directory"
+
+        def run(vault, name, version = nil)
+          output_dir = options[:output]
+
+          with_vault(vault) do |v|
+            ::FileUtils.mkdir_p(output_dir)
+
+            entries = v.gem_entries.select { |e| e.name == name }
+            entries = entries.select { |e| e.version == version } if version
+            if entries.empty?
+              print_error("No gem named '#{name}' in vault")
+              exit(1)
+            end
+
+            entries.each do |entry|
+              data = v.gem_data(entry.name, entry.version, platform: entry.platform)
+              File.binwrite(File.join(output_dir, entry.filename), data)
+              puts "Extracted #{entry.filename}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gemvault/cli/commands/list.rb

@@ -0,0 +1,26 @@
+require_relative "../command"
+
+module Gemvault
+  class CLI
+    module Commands
+      class List < Command
+        description "List gems in a vault"
+
+        argument :vault, required: true,
+                         usage: "VAULT",
+                         desc: "Vault file"
+
+        def run(vault)
+          with_vault(vault) do |v|
+            entries = v.gem_entries
+            if entries.empty?
+              puts "Vault is empty"
+            else
+              entries.each { |entry| puts entry }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gemvault/cli/commands/new.rb

@@ -0,0 +1,28 @@
+require_relative "../command"
+
+module Gemvault
+  class CLI
+    module Commands
+      class New < Command
+        description "Create a new vault"
+
+        argument :name, required: true,
+                        usage: "NAME",
+                        desc: "Vault name (auto-appends .gemv)"
+
+        def run(name)
+          path = name.end_with?(".gemv") ? name : "#{name}.gemv"
+
+          if File.exist?(path)
+            print_error("#{path} already exists")
+            exit(1)
+          end
+
+          vault = Vault.new(path, create: true)
+          vault.close
+          puts "Created #{path}"
+        end
+      end
+    end
+  end
+end

data/lib/gemvault/cli/commands/remove.rb

@@ -0,0 +1,34 @@
+require_relative "../command"
+
+module Gemvault
+  class CLI
+    module Commands
+      class Remove < Command
+        description "Remove gem(s) from a vault"
+
+        argument :vault, required: true,
+                         usage: "VAULT",
+                         desc: "Vault file"
+
+        argument :name, required: true,
+                        usage: "NAME",
+                        desc: "Gem name"
+
+        argument :version, required: false,
+                           usage: "VERSION",
+                           desc: "Gem version (omit to remove all versions)"
+
+        def run(vault, name, version = nil)
+          with_vault(vault) do |v|
+            count = v.remove(name, version)
+            if count.zero?
+              print_error("No matching gem found")
+              exit(1)
+            end
+            puts "Removed #{count} gem(s)"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gemvault/cli.rb

@@ -0,0 +1,45 @@
+require "command_kit/command"
+require "command_kit/commands/auto_load"
+require "command_kit/options/version"
+require_relative "version"
+
+module Gemvault
+  class CLI < CommandKit::Command
+    include CommandKit::Commands::AutoLoad.new(
+      dir: "#{__dir__}/cli/commands",
+      namespace: "#{name}::Commands",
+    )
+    include CommandKit::Options::Version
+
+    version Gemvault::VERSION
+    command_name "gemvault"
+    description "Manage gem vault archives"
+
+    examples [
+      "new myvault",
+      "add myvault.gemv foo-1.0.0.gem bar-2.0.0.gem",
+      "list myvault.gemv",
+      "extract myvault.gemv foo -o vendor/",
+    ]
+
+    def run(command = nil, *argv)
+      if command
+        super
+      else
+        help
+      end
+    end
+
+    def help
+      super
+      puts
+      puts "Gemfile usage:"
+      puts "  # REQUIRED until bundler-source-vault is published to rubygems.org:"
+      puts '  plugin "bundler-source-vault", path: "/path/to/gemvault"'
+      puts
+      puts '  source "myvault.gemv", type: :vault do'
+      puts '    gem "foo"'
+      puts "  end"
+    end
+  end
+end

data/lib/gemvault/gem_entry.rb

@@ -0,0 +1,37 @@
+module Gemvault
+  class GemEntry
+    attr_reader :name, :version, :platform, :created_at
+
+    def initialize(name:, version:, platform: "ruby", created_at: nil)
+      @name = name
+      @version = version
+      @platform = platform
+      @created_at = created_at
+    end
+
+    def full_name
+      platform == "ruby" ? "#{name}-#{version}" : "#{name}-#{version}-#{platform}"
+    end
+
+    def filename
+      "#{full_name}.gem"
+    end
+
+    def to_s
+      platform == "ruby" ? "#{name}-#{version}" : "#{name}-#{version} (#{platform})"
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        name == other.name &&
+        version == other.version &&
+        platform == other.platform
+    end
+
+    alias eql? ==
+
+    def hash
+      [name, version, platform].hash
+    end
+  end
+end

data/lib/gemvault/vault.rb

@@ -0,0 +1,178 @@
+require "sqlite3"
+require "rubygems/package"
+require "fileutils"
+require "tempfile"
+require_relative "gem_entry"
+
+module Gemvault
+  class Vault
+    class Error < StandardError; end
+    class NotFoundError < Error; end
+    class DuplicateGemError < Error; end
+    class InvalidGemError < Error; end
+
+    SCHEMA_VERSION = "1".freeze
+
+    attr_reader :path
+
+    def self.open(path, **opts, &block)
+      raise ArgumentError, "#{name}.open requires a block" unless block
+
+      vault = new(path, **opts)
+      begin
+        yield vault
+      ensure
+        vault.close
+      end
+    end
+
+    def initialize(path, create: false)
+      @path = File.expand_path(path)
+
+      if create
+        raise Error, "Vault already exists: #{@path}" if File.exist?(@path)
+
+        @db = SQLite3::Database.new(@path)
+        @db.results_as_hash = true
+        create_schema
+      else
+        raise NotFoundError, "Vault not found: #{@path}" unless File.exist?(@path)
+
+        validate_sqlite!
+        @db = SQLite3::Database.new(@path)
+        @db.results_as_hash = true
+      end
+    end
+
+    def add(gem_path)
+      gem_path = File.expand_path(gem_path)
+      raise NotFoundError, "Gem file not found: #{gem_path}" unless File.file?(gem_path)
+
+      begin
+        pkg = Gem::Package.new(gem_path)
+        spec = pkg.spec
+      rescue StandardError => e
+        raise InvalidGemError, "Invalid gem file #{gem_path}: #{e.message}"
+      end
+
+      name = spec.name
+      version = spec.version.to_s
+      platform = spec.platform.to_s
+
+      existing = @db.execute(
+        "SELECT 1 FROM gems WHERE name = ? AND version = ? AND platform = ?",
+        [name, version, platform],
+      )
+      unless existing.empty?
+        raise DuplicateGemError,
+              "Gem already in vault: #{name}-#{version} (#{platform})"
+      end
+
+      data = File.binread(gem_path)
+      @db.execute(
+        "INSERT INTO gems (name, version, platform, data) VALUES (?, ?, ?, ?)",
+        [name, version, platform, SQLite3::Blob.new(data)],
+      )
+    end
+
+    def remove(name, version = nil)
+      if version
+        @db.execute(
+          "DELETE FROM gems WHERE name = ? AND version = ?",
+          [name, version],
+        )
+      else
+        @db.execute(
+          "DELETE FROM gems WHERE name = ?",
+          [name],
+        )
+      end
+      @db.changes
+    end
+
+    def gem_data(name, version, platform: "ruby")
+      row = @db.execute(
+        "SELECT data FROM gems WHERE name = ? AND version = ? AND platform = ?",
+        [name, version, platform],
+      ).first
+
+      raise NotFoundError, "Gem not found: #{name}-#{version} (#{platform})" unless row
+
+      row["data"]
+    end
+
+    def specs
+      gem_entries.map { |entry| spec_from_blob(entry.name, entry.version, entry.platform) }
+    end
+
+    def gem_entries
+      @db.execute(
+        "SELECT name, version, platform, created_at FROM gems ORDER BY name, version",
+      ).map { |row| GemEntry.new(**row.transform_keys(&:to_sym)) }
+    end
+
+    def size
+      @db.execute("SELECT COUNT(*) AS count FROM gems").first["count"]
+    end
+
+    def close
+      @db.close if @db && !@db.closed?
+    end
+
+    def with_gem_file(name, version, platform: "ruby")
+      data = gem_data(name, version, platform: platform)
+      tmpfile = Tempfile.new(["vault_gem", ".gem"])
+      begin
+        tmpfile.binmode
+        tmpfile.write(data)
+        tmpfile.close
+        yield tmpfile.path
+      ensure
+        tmpfile.close unless tmpfile.closed?
+        tmpfile.unlink
+      end
+    end
+
+    def spec_from_blob(name, version, platform = "ruby")
+      with_gem_file(name, version, platform: platform) do |path|
+        Gem::Package.new(path).spec
+      end
+    end
+
+    private
+
+    def create_schema
+      @db.execute_batch(<<~SQL)
+        CREATE TABLE metadata (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        );
+
+        CREATE TABLE gems (
+          name TEXT NOT NULL,
+          version TEXT NOT NULL,
+          platform TEXT NOT NULL DEFAULT 'ruby',
+          data BLOB NOT NULL,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          PRIMARY KEY (name, version, platform)
+        );
+      SQL
+
+      @db.execute(
+        "INSERT INTO metadata (key, value) VALUES (?, ?)",
+        ["vault_version", SCHEMA_VERSION],
+      )
+      @db.execute(
+        "INSERT INTO metadata (key, value) VALUES (?, ?)",
+        ["created_at", Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")],
+      )
+    end
+
+    def validate_sqlite!
+      magic = File.binread(@path, 16)
+      return if magic == "SQLite format 3\x00"
+
+      raise Error, "Not a valid vault file (not SQLite): #{@path}"
+    end
+  end
+end

data/lib/gemvault/version.rb

@@ -0,0 +1,3 @@
+module Gemvault
+  VERSION = "0.1.1".freeze
+end

data/lib/gemvault.rb

@@ -0,0 +1,10 @@
+require_relative "gemvault/version"
+require_relative "gemvault/vault"
+
+##
+# Top-level namespace for the gemvault gem.
+module Gemvault
+  ##
+  # Base error class for gemvault.
+  class Error < StandardError; end
+end

data/lib/rubygems/resolver/vault_set.rb

@@ -0,0 +1,39 @@
+##
+# A VaultSet looks up specifications from a .gemv vault source.
+#
+# Returns standard Gem::Resolver::IndexSpecification objects so the
+# resolver's install pipeline (download -> Gem::Installer) works unchanged.
+
+class Gem::Resolver::VaultSet < Gem::Resolver::Set
+  def initialize(source)
+    super()
+    @source = source
+    @specs = source.load_specs(:complete)
+  end
+
+  def find_all(req)
+    @specs.select { |tuple| req.match?(tuple) }.map do |tuple|
+      Gem::Resolver::IndexSpecification.new(
+        self,
+        tuple.name,
+        tuple.version,
+        @source,
+        tuple.platform,
+      )
+    end
+  end
+
+  def prefetch(reqs); end
+
+  def pretty_print(q)
+    q.group 2, "[VaultSet", "]" do
+      next if @specs.empty?
+
+      q.breakable
+
+      q.seplist @specs do |tuple|
+        q.text tuple.full_name
+      end
+    end
+  end
+end