paquette 0.1.0

data/lib/paquette/npm_server/gated_npm_repository.rb

@@ -0,0 +1,66 @@
+require "delegate"
+
+module Paquette
+  class NpmServer
+    class GatedNpmRepository < SimpleDelegator
+      def initialize(repository, &entitler)
+        super(repository)
+        @entitler = entitler
+      end
+
+      def package_names
+        super.select { |name| @entitler.call(name: name) }
+      end
+
+      def package_versions
+        super.select do |package_name, version|
+          @entitler.call(name: package_name, version: version)
+        end
+      end
+
+      def versions_for_package(package_name)
+        return [] unless @entitler.call(name: package_name)
+        super.select do |version|
+          @entitler.call(name: package_name, version: version)
+        end
+      end
+
+      def package_file_path(package_name, version)
+        if @entitler.call(name: package_name, version: version)
+          super
+        end
+      end
+
+      def package_metadata(package_name)
+        return nil unless @entitler.call(name: package_name)
+
+        # Get the metadata from the underlying repository, but filter by entitled versions
+        metadata = super
+        return metadata unless metadata
+
+        # Filter versions based on entitlements
+        entitled_versions = versions_for_package(package_name)
+
+        # Update the versions hash to only include entitled versions
+        metadata[:versions] = metadata[:versions].slice(*entitled_versions)
+
+        # Update time entries to only include entitled versions
+        metadata[:time] = metadata[:time].slice(*entitled_versions)
+
+        # Update dist-tags to use the latest entitled version
+        if entitled_versions.any?
+          latest_entitled = entitled_versions.max_by { |v| Gem::Version.new(v) }
+          metadata[:"dist-tags"][:latest] = latest_entitled
+        end
+
+        metadata
+      end
+
+      def package_exists?(package_name, version)
+        if @entitler.call(name: package_name, version: version)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/paquette/npm_server/npm_repository.rb

@@ -0,0 +1,53 @@
+require "json"
+require "fileutils"
+
+module Paquette
+  class NpmServer
+    # Abstract base class for NPM package repositories
+    class NpmRepository
+      def initialize
+        raise NotImplementedError, "NpmRepository is an abstract class"
+      end
+
+      # Returns an array of package names available in the repository
+      def package_names
+        raise NotImplementedError, "Subclasses must implement package_names"
+      end
+
+      # Returns an array of [name, version] pairs for all packages
+      def package_versions
+        raise NotImplementedError, "Subclasses must implement package_versions"
+      end
+
+      # Returns an array of versions for a specific package
+      def versions_for_package(package_name)
+        raise NotImplementedError, "Subclasses must implement versions_for_package"
+      end
+
+      # Returns the package file path for a specific package and version
+      def package_file_path(package_name, version)
+        raise NotImplementedError, "Subclasses must implement package_file_path"
+      end
+
+      # Returns whether a package file exists for the given name and version
+      def package_exists?(package_name, version)
+        raise NotImplementedError, "Subclasses must implement package_exists?"
+      end
+
+      # Returns the package.json for a specific package and version
+      def package_info(package_name, version)
+        raise NotImplementedError, "Subclasses must implement package_info"
+      end
+
+      # Returns dependencies for a specific package and version
+      def package_dependencies(package_name, version)
+        raise NotImplementedError, "Subclasses must implement package_dependencies"
+      end
+
+      # Returns the full package metadata for NPM registry format
+      def package_metadata(package_name)
+        raise NotImplementedError, "Subclasses must implement package_metadata"
+      end
+    end
+  end
+end

data/lib/paquette/npm_server.rb

@@ -0,0 +1,98 @@
+require "json"
+require "fileutils"
+require_relative "routes"
+require_relative "npm_server/directory_npm_repository"
+require_relative "npm_server/gated_npm_repository"
+
+module Paquette
+  class NpmServer
+    @@routes = Routes.draw do |r|
+      # Root endpoint
+      r.get "/" do
+        text_ok("Paquette NPM Repository")
+      end
+
+      # NPM API endpoints
+      r.get "/-/ping" do
+        json_ok({})
+      end
+
+      r.get "/-/whoami" do
+        json_ok({username: "paquette"})
+      end
+
+      # Dynamic endpoints with parameters
+      r.get "/-/package/:package_name/dist-tags" do |package_name:|
+        metadata = @repository.package_metadata(package_name)
+        if metadata && metadata[:"dist-tags"]
+          json_ok(metadata[:"dist-tags"])
+        else
+          not_found("Package not found")
+        end
+      end
+
+      r.get "/:package_name" do |package_name:|
+        metadata = @repository.package_metadata(package_name)
+        if metadata
+          json_ok(metadata)
+        else
+          not_found("Package not found")
+        end
+      end
+
+      r.get "/:package_name/:tarball_name" do |package_name:, tarball_name:|
+        # Extract version from tarball name (e.g., "package-1.0.0.tgz")
+        if (match = tarball_name.match(/^#{Regexp.escape(package_name)}-(\d+\.\d+\.\d+.*)\.tgz$/))
+          version = match[1]
+          package_path = @repository.package_file_path(package_name, version)
+
+          if @repository.package_exists?(package_name, version)
+            [200, {"Content-Type" => "application/octet-stream"}, [File.read(package_path)]]
+          else
+            not_found("Package not found")
+          end
+        else
+          not_found("Invalid package filename")
+        end
+      end
+    end
+
+    def initialize(packages_dir)
+      @dir_repository = DirectoryNpmRepository.new(packages_dir)
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      @repository = GatedNpmRepository.new(@dir_repository) { |name:, version: nil| true }
+
+      if (route = @@routes.match(request))
+        @@routes.perform_action(route, self, request)
+      else
+        not_found("Not Found")
+      end
+    end
+
+    private
+
+    # Helper methods for common response patterns
+    def json_ok(data)
+      [200, {"Content-Type" => "application/json"}, [JSON.pretty_generate(data)]]
+    end
+
+    def text_ok(data)
+      [200, {"Content-Type" => "text/plain"}, [data]]
+    end
+
+    def not_found(message = "Not Found")
+      [404, {"Content-Type" => "text/plain"}, [message]]
+    end
+
+    def bad_request(message = "Bad Request")
+      [400, {"Content-Type" => "text/plain"}, [message]]
+    end
+
+    def server_error(message = "Internal Server Error")
+      [500, {"Content-Type" => "text/plain"}, [message]]
+    end
+  end
+end

data/lib/paquette/routes.rb

@@ -0,0 +1,78 @@
+require "mustermann"
+
+module Paquette
+  class Routes
+    class Route
+      attr_reader :method, :pattern, :block
+
+      def initialize(method, pattern, block)
+        @method = method
+        @pattern = Mustermann.new(pattern)
+        @block = block
+      end
+
+      def match?(request)
+        @method == request.request_method && @pattern.match(request.path_info)
+      end
+
+      def params(request)
+        @pattern.params(request.path_info)
+      end
+
+      def perform_action(instance, request)
+        # Extract params and pass them as keyword arguments
+        route_params = params(request)
+        # Also include query parameters
+        query_params = request.params
+        # Convert string keys to symbols for keyword arguments
+        symbol_params = route_params.merge(query_params).transform_keys(&:to_sym)
+        instance.instance_exec(**symbol_params, &@block)
+      end
+    end
+
+    class RouteBuilder
+      def initialize(routes)
+        @routes = routes
+      end
+
+      def get(pattern, &block)
+        @routes << Route.new("GET", pattern, block)
+      end
+
+      def post(pattern, &block)
+        @routes << Route.new("POST", pattern, block)
+      end
+
+      def put(pattern, &block)
+        @routes << Route.new("PUT", pattern, block)
+      end
+
+      def delete(pattern, &block)
+        @routes << Route.new("DELETE", pattern, block)
+      end
+
+      def patch(pattern, &block)
+        @routes << Route.new("PATCH", pattern, block)
+      end
+    end
+
+    def self.draw(&block)
+      routes = []
+      builder = RouteBuilder.new(routes)
+      block.call(builder)
+      new(routes)
+    end
+
+    def initialize(routes)
+      @routes = routes
+    end
+
+    def match(request)
+      @routes.find { |route| route.match?(request) }
+    end
+
+    def perform_action(route, instance, request)
+      route.perform_action(instance, request)
+    end
+  end
+end

data/lib/paquette/subdomain_router.rb

@@ -0,0 +1,59 @@
+require_relative "gem_server"
+require_relative "npm_server"
+
+module Paquette
+  class SubdomainRouter
+    def initialize(&block)
+      @mappings = {}
+      @fallback = nil
+
+      if block_given?
+        block.call(self)
+      end
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      host = request.host
+
+      # Extract subdomain from host
+      subdomain = extract_subdomain(host)
+
+      if subdomain && @mappings[subdomain]
+        app = @mappings[subdomain]
+        if app.respond_to?(:call)
+          app.call(env)
+        else
+          # If it's a class, instantiate it
+          app.new.call(env)
+        end
+      elsif @fallback
+        @fallback.call(env)
+      else
+        [404, {}, ["Subdomain not found"]]
+      end
+    end
+
+    def map(subdomain, to:)
+      @mappings[subdomain] = to
+    end
+
+    def fallback(to:)
+      @fallback = to
+    end
+
+    private
+
+    def extract_subdomain(host)
+      # Handle localhost with port (e.g., localhost:9292)
+      host = host.split(":").first if host.include?(":")
+
+      # Extract the first part of the hostname (subdomain)
+      if (match = host.match(/^([a-z\-\d]+)\./))
+        subdomain = match[1]
+        # Only return if this subdomain is actually mapped
+        @mappings.key?(subdomain) ? subdomain : nil
+      end
+    end
+  end
+end

data/lib/paquette/version.rb

@@ -0,0 +1,3 @@
+module Paquette
+  VERSION = "0.1.0"
+end

data/lib/paquette.rb

@@ -0,0 +1,12 @@
+module Paquette
+  require_relative "paquette/version"
+
+  require_relative "paquette/routes"
+  require_relative "paquette/gem_server/gem_repository"
+  require_relative "paquette/gem_server/directory_gem_repository"
+  require_relative "paquette/gem_server"
+  require_relative "paquette/npm_server"
+  require_relative "paquette/subdomain_router"
+  require_relative "paquette/gem_server/gem_repacker"
+  require_relative "paquette/npm_repacker"
+end

data/test/gem_server/bundler_install_test.rb

@@ -0,0 +1,86 @@
+require_relative "../test_helper"
+require "socket"
+
+class BundlerInstallTest < Minitest::Test
+  def setup
+    @server_thread = nil
+  end
+
+  def teardown
+    stop_server if @server_thread
+  end
+
+  def test_gem_installation
+    start_server
+    sleep 2
+    # wait_for_server
+
+    tempdir = Dir.mktmpdir
+    pid = fork do
+      Dir.chdir(tempdir)
+      File.open("Gemfile", "w") do |gemfile|
+        gemfile << <<~RUBY
+          source "http://gem.localhost:#{@server_port}" do
+            gem "zip_kit"
+            gem "minuscule_test"
+          end
+        RUBY
+      end
+      Bundler.with_unbundled_env do
+        ENV["BUNDLE_GEMFILE"] = Dir.pwd + "/Gemfile"
+        system("bundle config set --local disable_checksum_validation true")
+        system("bundle install --verbose")
+      end
+    end
+    Process.wait(pid)
+  ensure
+    stop_server
+  end
+
+  private
+
+  def find_free_port
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    server.close
+    port
+  end
+
+  def start_server
+    return if @server_thread
+    @server_port = find_free_port
+    env = {"PAQUETTE_PACKAGES_DIR" => File.expand_path("../fixtures", __dir__)}
+    cmd = "puma --port #{@server_port} -e test"
+
+    @server_thread ||= Thread.new { system(env, cmd) }
+  end
+
+  def stop_server
+    return unless @server_thread
+
+    # Kill the puma process
+    system("pkill -f 'puma.*#{@server_port}'")
+    @server_thread.kill
+    @server_thread.join(1) # Wait up to 1 second for thread to finish
+    @server_thread = nil
+  end
+
+  def wait_for_server
+    max_attempts = 50 # 5 seconds with 0.1 second intervals
+    attempts = 0
+
+    while attempts < max_attempts
+      begin
+        response = Net::HTTP.get_response(URI("http://127.0.0.1:#{@server_port}/"))
+        return if response.code == "200"
+      rescue
+        # Server not ready yet
+      end
+
+      sleep 0.1
+      attempts += 1
+    end
+
+    flunk "Server did not start within 5 seconds"
+  end
+end

data/test/gem_server/directory_gem_repository_test.rb

@@ -0,0 +1,208 @@
+require_relative "../test_helper"
+
+class DirectoryGemRepositoryTest < Minitest::Test
+  def setup
+    @gems_dir = FIXTURE_GEMS_DIR
+    @repository = Paquette::GemServer::DirectoryGemRepository.new(@gems_dir)
+    @minuscule_fixture = File.join(@gems_dir, "minuscule_test", "minuscule_test-0.1.0.gem")
+  end
+
+  def test_gem_names
+    names = @repository.gem_names
+    assert_equal ["minuscule_test", "zip_kit"], names.sort
+  end
+
+  def test_gem_versions
+    versions = @repository.gem_versions
+    assert_equal 3, versions.length
+
+    # standard:disable Style/HashSlice
+    zip_kit_versions = versions.select { |name, _| name == "zip_kit" }
+    # standard:enable Style/HashSlice
+    assert_equal 2, zip_kit_versions.length
+    assert_includes zip_kit_versions.map { |_, v| v }, "6.2.0"
+    assert_includes zip_kit_versions.map { |_, v| v }, "6.2.1"
+
+    # standard:disable Style/HashSlice
+    minuscule_versions = versions.select { |name, _| name == "minuscule_test" }
+    # standard:enable Style/HashSlice
+    assert_equal 1, minuscule_versions.length
+    assert_includes minuscule_versions.map { |_, v| v }, "0.1.0"
+  end
+
+  def test_versions_for_gem
+    zip_kit_versions = @repository.versions_for_gem("zip_kit")
+    assert_equal 2, zip_kit_versions.length
+    assert_includes zip_kit_versions, "6.2.0"
+    assert_includes zip_kit_versions, "6.2.1"
+
+    minuscule_versions = @repository.versions_for_gem("minuscule_test")
+    assert_equal ["0.1.0"], minuscule_versions
+
+    assert_equal [], @repository.versions_for_gem("nonexistent")
+  end
+
+  def test_gem_exists
+    assert @repository.gem_exists?("zip_kit", "6.2.0")
+    assert @repository.gem_exists?("zip_kit", "6.2.1")
+    assert @repository.gem_exists?("minuscule_test", "0.1.0")
+
+    refute @repository.gem_exists?("zip_kit", "6.3.2")
+    refute @repository.gem_exists?("nonexistent", "1.0.0")
+  end
+
+  def test_gem_file_path
+    assert_equal File.join(@gems_dir, "zip_kit", "zip_kit-6.2.0.gem"),
+      @repository.gem_file_path("zip_kit", "6.2.0")
+    assert_equal File.join(@gems_dir, "minuscule_test", "minuscule_test-0.1.0.gem"),
+      @repository.gem_file_path("minuscule_test", "0.1.0")
+  end
+
+  def test_gem_spec
+    spec = @repository.gem_spec("zip_kit", "6.2.0")
+    refute_nil spec
+    assert_equal "zip_kit", spec.name
+    assert_equal "6.2.0", spec.version.to_s
+
+    spec = @repository.gem_spec("minuscule_test", "0.1.0")
+    refute_nil spec
+    assert_equal "minuscule_test", spec.name
+    assert_equal "0.1.0", spec.version.to_s
+
+    assert_nil @repository.gem_spec("nonexistent", "1.0.0")
+  end
+
+  def test_gem_dependencies
+    assert @repository.gem_dependencies("zip_kit", "6.2.0").is_a?(Array)
+    assert @repository.gem_dependencies("minuscule_test", "0.1.0").is_a?(Array)
+    assert_equal [], @repository.gem_dependencies("nonexistent", "1.0.0")
+  end
+
+  def test_add_gem_persists_file_and_returns_spec
+    binary = File.binread(@minuscule_fixture)
+
+    Dir.mktmpdir do |tmp|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(tmp)
+
+      spec = repo.add_gem(binary)
+
+      assert_equal "minuscule_test", spec.name
+      assert_equal "0.1.0", spec.version.to_s
+      assert repo.gem_exists?("minuscule_test", "0.1.0")
+      assert_equal binary, File.binread(repo.gem_file_path("minuscule_test", "0.1.0"))
+    end
+  end
+
+  def test_add_gem_rejects_duplicate
+    binary = File.binread(@minuscule_fixture)
+
+    Dir.mktmpdir do |tmp|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(tmp)
+      repo.add_gem(binary)
+
+      assert_raises(Paquette::GemServer::DirectoryGemRepository::GemAlreadyExists) do
+        repo.add_gem(binary)
+      end
+    end
+  end
+
+  def test_add_gem_rejects_invalid_payload
+    Dir.mktmpdir do |tmp|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(tmp)
+
+      assert_raises(Paquette::GemServer::DirectoryGemRepository::InvalidGem) do
+        repo.add_gem("")
+      end
+
+      assert_raises(Paquette::GemServer::DirectoryGemRepository::InvalidGem) do
+        repo.add_gem("not a real gem file")
+      end
+    end
+  end
+
+  def test_yank_gem_moves_file_to_tomb
+    binary = File.binread(@minuscule_fixture)
+
+    Dir.mktmpdir do |tmp|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(tmp)
+      repo.add_gem(binary)
+
+      repo.yank_gem("minuscule_test", "0.1.0")
+
+      refute repo.gem_exists?("minuscule_test", "0.1.0")
+      assert repo.tomb_exists?("minuscule_test", "0.1.0")
+      assert_equal binary, File.binread(repo.tomb_file_path("minuscule_test", "0.1.0"))
+    end
+  end
+
+  def test_yank_excludes_gem_from_listings
+    binary = File.binread(@minuscule_fixture)
+
+    Dir.mktmpdir do |tmp|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(tmp)
+      repo.add_gem(binary)
+      repo.yank_gem("minuscule_test", "0.1.0")
+
+      assert_equal [], repo.versions_for_gem("minuscule_test")
+      assert_equal [], repo.gem_versions
+      assert_equal [], repo.compact_info("minuscule_test")
+    end
+  end
+
+  def test_yank_gem_raises_when_missing
+    Dir.mktmpdir do |tmp|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(tmp)
+
+      assert_raises(Paquette::GemServer::DirectoryGemRepository::GemNotFound) do
+        repo.yank_gem("nonexistent", "1.0.0")
+      end
+    end
+  end
+
+  def test_yank_twice_raises_not_found
+    binary = File.binread(@minuscule_fixture)
+
+    Dir.mktmpdir do |tmp|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(tmp)
+      repo.add_gem(binary)
+      repo.yank_gem("minuscule_test", "0.1.0")
+
+      assert_raises(Paquette::GemServer::DirectoryGemRepository::GemNotFound) do
+        repo.yank_gem("minuscule_test", "0.1.0")
+      end
+    end
+  end
+
+  def test_add_gem_refuses_when_tombed
+    binary = File.binread(@minuscule_fixture)
+
+    Dir.mktmpdir do |tmp|
+      repo = Paquette::GemServer::DirectoryGemRepository.new(tmp)
+      repo.add_gem(binary)
+      repo.yank_gem("minuscule_test", "0.1.0")
+
+      assert_raises(Paquette::GemServer::DirectoryGemRepository::GemYanked) do
+        repo.add_gem(binary)
+      end
+    end
+  end
+
+  def test_compact_info
+    info = @repository.compact_info("zip_kit")
+    assert info.is_a?(Array)
+    assert_equal 2, info.length
+    info.each do |line|
+      assert_match(/^\S+\s+\|checksum:[a-f0-9]{64},ruby:.+$/, line, "Line should match compact index format: #{line}")
+    end
+    versions = info.map { |line| line.split(" ")[0] }
+    assert_includes versions, "6.2.0"
+    assert_includes versions, "6.2.1"
+
+    info = @repository.compact_info("minuscule_test")
+    assert info.is_a?(Array)
+    assert_equal 1, info.length
+    assert_match(/^0\.1\.0\s+\|checksum:[a-f0-9]{64},ruby:.+$/, info[0])
+
+    assert_equal [], @repository.compact_info("nonexistent")
+  end
+end