rubylens 0.2.0 → 0.2.1

data/lib/rubylens/index/manifest.rb

@@ -2,33 +2,17 @@
 
 require "bundler"
 require "bundler/lockfile_parser"
-require "find"
 require "pathname"
 require "set"
 require_relative "../dependency_warning"
+require_relative "git_package_source"
 
 module RubyLens
   module Index
     class Manifest
       Package = Data.define(:name, :version, :role, :location, :root, :files)
       DependencySystem = Data.define(:id, :package_indexes, :label_package_index)
-      GitPackagePaths = Data.define(:logical_root, :canonical_root, :logical_canonical_root)
 
-      class NixStoreProvider
-        STORE_ROOT = Pathname("/nix/store").freeze
-        STORE_OBJECT_PATTERN = /\A[0123456789abcdfghijklmnpqrsvwxyz]{32}-.+\z/
-
-        def trusted?(path)
-          path = Pathname(path).expand_path
-          return false unless Paths.inside?(path, STORE_ROOT)
-
-          first_component = path.relative_path_from(STORE_ROOT).each_filename.first
-          first_component && STORE_OBJECT_PATTERN.match?(first_component)
-        end
-      end
-
-      UnsafeGitRequirePath = Class.new(StandardError)
-      UnsafeGitPackageFile = Class.new(StandardError)
       GIT_SKIP_REASONS = DependencyWarning::REASONS
 
       attr_reader :root, :files, :workspace_files, :packages, :dependency_systems, :warnings, :dependency_warnings
@@ -40,7 +24,7 @@ module RubyLens
       def initialize(root:, lockfile: nil)
         @root = Pathname(root).expand_path.realpath
         @lockfile = Pathname(lockfile || @root.join("Gemfile.lock")).expand_path
-        @nix_store_provider = NixStoreProvider.new
+        @git_package_source = GitPackageSource.new(lockfile: @lockfile)
         @warnings = []
         @dependency_warnings = []
         @packages = []
@@ -49,7 +33,7 @@ module RubyLens
         @package_index_by_file = {}
         @package_index_cache = {}
         @relative_workspace_path_cache = {}
-        @git_spec_indexes = {}.compare_by_identity
+        @workspace_path_cache = {}
       end
 
       def build
@@ -80,7 +64,10 @@ module RubyLens
       end
 
       def workspace_path?(path)
-        Paths.inside?(path, @root)
+        path = path.to_s
+        @workspace_path_cache.fetch(path) do
+          @workspace_path_cache[path] = Paths.inside?(path, @root)
+        end
       end
 
       def relative_workspace_path(path)
@@ -189,134 +176,17 @@ module RubyLens
       end
 
       def git_package(locked, role)
-        source = locked.source
-        return skip_git_dependency(locked, :local_only_required) if source.allow_git_ops?
-
-        checkout = git_checkout_path(source)
-        return skip_git_dependency(locked, :checkout_unavailable) unless checkout.directory?
-
-        specification = (@git_spec_indexes[source] ||= git_specifications(source, checkout)).search(locked).first
-        return skip_git_dependency(locked, :specification_unavailable) unless specification
-
-        paths = git_package_paths(specification, checkout)
-        return skip_git_dependency(locked, :unsafe_specification_root) unless paths
-
-        files = git_indexable_files(paths, specification.require_paths)
+        resolution = @git_package_source.resolve(locked)
+        return skip_git_dependency(locked, resolution) if resolution.is_a?(Symbol)
 
         Package.new(
           name: locked.name,
           version: locked.version.to_s,
           role: role,
           location: "external",
-          root: paths.canonical_root,
-          files: files.freeze,
+          root: resolution.root,
+          files: resolution.files,
         )
-      rescue UnsafeGitRequirePath
-        skip_git_dependency(locked, :unsafe_require_paths)
-      rescue UnsafeGitPackageFile
-        skip_git_dependency(locked, :unsafe_package_files)
-      rescue Bundler::BundlerError, Gem::Exception
-        skip_git_dependency(locked, :specification_unreadable)
-      rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
-        skip_git_dependency(locked, :checkout_unavailable)
-      end
-
-      def git_checkout_path(source)
-        bundle_root = @lockfile.dirname
-        app_config = ENV["BUNDLE_APP_CONFIG"]
-        app_config_path = if app_config
-          Pathname(app_config).expand_path(bundle_root)
-        else
-          bundle_root.join(".bundle")
-        end
-        bundle_path = Pathname(Bundler::Settings.new(app_config_path).path.path).expand_path(bundle_root)
-        bundle_path.join("bundler/gems", source.extension_dir_name)
-      end
-
-      def git_specifications(source, checkout)
-        source.__send__(:set_install_path!, checkout)
-        source.specs
-      end
-
-      def git_package_paths(specification, checkout)
-        logical_root = Pathname(specification.full_gem_path).expand_path
-        logical_gemspec = Pathname(specification.loaded_from).expand_path
-        return unless Paths.inside?(logical_root, checkout)
-        return unless logical_gemspec.dirname == logical_root
-        return unless logical_gemspec.file? && logical_root.directory?
-
-        canonical_checkout = checkout.realpath
-        resolved_gemspec_root = logical_gemspec.realpath.dirname
-        logical_canonical_root = logical_root.realpath
-        return unless resolved_gemspec_root.directory?
-        normal_checkout = !checkout.symlink? &&
-          Paths.inside?(resolved_gemspec_root, canonical_checkout) &&
-          Paths.inside?(logical_canonical_root, canonical_checkout)
-        return unless normal_checkout || @nix_store_provider.trusted?(resolved_gemspec_root)
-
-        canonical_root = normal_checkout ? logical_canonical_root : resolved_gemspec_root
-
-        GitPackagePaths.new(
-          logical_root: logical_root,
-          canonical_root: canonical_root,
-          logical_canonical_root: logical_canonical_root,
-        )
-      rescue TypeError, ArgumentError
-        nil
-      end
-
-      def git_indexable_files(paths, require_paths)
-        logical_require_paths = require_paths.map do |relative_path|
-          raise UnsafeGitRequirePath unless relative_path.is_a?(String)
-
-          relative = Pathname(relative_path)
-          raise UnsafeGitRequirePath if relative.absolute? || relative.each_filename.include?("..")
-
-          candidate = paths.logical_root.join(relative).cleanpath
-          raise UnsafeGitRequirePath unless Paths.inside?(candidate, paths.logical_root)
-
-          candidate
-        rescue ArgumentError, EncodingError
-          raise UnsafeGitRequirePath
-        end
-
-        files = []
-        visited_directories = Set.new
-        logical_require_paths.each do |path|
-          next unless path.exist? || path.symlink?
-
-          traverse_git_package_path(path, paths, files, visited_directories, Set.new)
-        end
-        files.uniq.sort
-      end
-
-      def traverse_git_package_path(path, paths, files, visited_directories, active_directories)
-        resolved = path.realpath
-        if resolved.file?
-          raise UnsafeGitPackageFile unless Paths.inside?(resolved, paths.canonical_root)
-
-          files << resolved.to_s if indexable?(path)
-          return
-        end
-        return unless resolved.directory?
-
-        unless Paths.inside?(resolved, paths.logical_canonical_root) || Paths.inside?(resolved, paths.canonical_root)
-          raise UnsafeGitPackageFile
-        end
-        raise UnsafeGitPackageFile if active_directories.include?(resolved)
-        return if visited_directories.include?(resolved)
-
-        active_directories.add(resolved)
-        begin
-          path.children.sort_by(&:to_s).each do |child|
-            traverse_git_package_path(child, paths, files, visited_directories, active_directories)
-          end
-          visited_directories.add(resolved)
-        ensure
-          active_directories.delete(resolved)
-        end
-      rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
-        raise UnsafeGitPackageFile
       end
 
       def skip_git_dependency(locked, reason_code)
@@ -429,20 +299,54 @@ module RubyLens
         end.flat_map { |path| enumerate(path, root) }.uniq.sort
       end
 
+      # Walks an already-canonical directory (the caller resolved and containment-checked
+      # it) without re-resolving every entry: descending only non-symlink directories
+      # keeps each joined path canonical, so regular files join the list with a cheap
+      # prefix containment check and only symlinked entries pay for a realpath. Symlinked
+      # directories are never descended, matching Find.find's lstat-based traversal.
       def enumerate(path, root)
         return [path.to_s] if path.file? && indexable?(path) && Paths.inside?(path.realpath, root)
         return [] unless path.directory?
+        return [] if path.symlink?
 
         files = []
-        Find.find(path) do |candidate|
-          candidate = Pathname(candidate)
-          next if candidate.directory?
-          next unless indexable?(candidate)
-
-          resolved = candidate.realpath
-          files << resolved.to_s if Paths.inside?(resolved, root)
-        rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
-          next
+        root_prefix = "#{root}#{File::SEPARATOR}"
+        start = path.to_s
+        # Child names must come back in the starting path's encoding. A package
+        # root that is not valid UTF-8 otherwise yields UTF-8 entry names that
+        # cannot be joined to it, and the whole build aborts on a tree the
+        # Find-based walk indexed fine.
+        encoding = start.encoding == Encoding::US_ASCII ? Encoding.find("filesystem") : start.encoding
+        pending = [start]
+        while (directory = pending.pop)
+          entries = begin
+            Dir.children(directory, encoding: encoding)
+          rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG, Errno::EINVAL
+            next
+          end
+          entries.each do |entry|
+            candidate = File.join(directory, entry)
+            stat = begin
+              File.lstat(candidate)
+            rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG, Errno::EINVAL
+              next
+            end
+            if stat.symlink?
+              next if File.directory?(candidate)
+              next unless INDEXABLE_EXTENSIONS.include?(File.extname(entry))
+
+              begin
+                resolved = File.realpath(candidate)
+                files << resolved if Paths.inside?(resolved, root)
+              rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
+                next
+              end
+            elsif stat.directory?
+              pending << candidate
+            elsif INDEXABLE_EXTENSIONS.include?(File.extname(entry))
+              files << candidate if candidate.start_with?(root_prefix)
+            end
+          end
         end
         files
       end