From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/lib/rubygems/exceptions.rb | 270 ++++++++++++++++++++++++++++++++++++ 1 file changed, 270 insertions(+) create mode 100644 jni/ruby/lib/rubygems/exceptions.rb (limited to 'jni/ruby/lib/rubygems/exceptions.rb') diff --git a/jni/ruby/lib/rubygems/exceptions.rb b/jni/ruby/lib/rubygems/exceptions.rb new file mode 100644 index 0000000..2a9875c --- /dev/null +++ b/jni/ruby/lib/rubygems/exceptions.rb @@ -0,0 +1,270 @@ +# TODO: the documentation in here is terrible. +# +# Each exception needs a brief description and the scenarios where it is +# likely to be raised + +## +# Base exception class for RubyGems. All exception raised by RubyGems are a +# subclass of this one. +class Gem::Exception < RuntimeError + + ## + #-- + # TODO: remove in RubyGems 3, nobody sets this + + attr_accessor :source_exception # :nodoc: + +end + +class Gem::CommandLineError < Gem::Exception; end + +class Gem::DependencyError < Gem::Exception; end + +class Gem::DependencyRemovalException < Gem::Exception; end + +## +# Raised by Gem::Resolver when a Gem::Dependency::Conflict reaches the +# toplevel. Indicates which dependencies were incompatible through #conflict +# and #conflicting_dependencies + +class Gem::DependencyResolutionError < Gem::DependencyError + + attr_reader :conflict + + def initialize conflict + @conflict = conflict + a, b = conflicting_dependencies + + super "conflicting dependencies #{a} and #{b}\n#{@conflict.explanation}" + end + + def conflicting_dependencies + @conflict.conflicting_dependencies + end + +end + +## +# Raised when attempting to uninstall a gem that isn't in GEM_HOME. + +class Gem::GemNotInHomeException < Gem::Exception + attr_accessor :spec +end + +class Gem::DocumentError < Gem::Exception; end + +## +# Potentially raised when a specification is validated. +class Gem::EndOfYAMLException < Gem::Exception; end + +## +# Signals that a file permission error is preventing the user from +# operating on the given directory. + +class Gem::FilePermissionError < Gem::Exception + + attr_reader :directory + + def initialize directory + @directory = directory + + super "You don't have write permissions for the #{directory} directory." + end + +end + +## +# Used to raise parsing and loading errors +class Gem::FormatException < Gem::Exception + attr_accessor :file_path +end + +class Gem::GemNotFoundException < Gem::Exception; end + +## +# Raised by the DependencyInstaller when a specific gem cannot be found + +class Gem::SpecificGemNotFoundException < Gem::GemNotFoundException + + ## + # Creates a new SpecificGemNotFoundException for a gem with the given +name+ + # and +version+. Any +errors+ encountered when attempting to find the gem + # are also stored. + + def initialize(name, version, errors=nil) + super "Could not find a valid gem '#{name}' (#{version}) locally or in a repository" + + @name = name + @version = version + @errors = errors + end + + ## + # The name of the gem that could not be found. + + attr_reader :name + + ## + # The version of the gem that could not be found. + + attr_reader :version + + ## + # Errors encountered attempting to find the gem. + + attr_reader :errors + +end + +## +# Raised by Gem::Resolver when dependencies conflict and create the +# inability to find a valid possible spec for a request. + +class Gem::ImpossibleDependenciesError < Gem::Exception + + attr_reader :conflicts + attr_reader :request + + def initialize request, conflicts + @request = request + @conflicts = conflicts + + super build_message + end + + def build_message # :nodoc: + requester = @request.requester + requester = requester ? requester.spec.full_name : 'The user' + dependency = @request.dependency + + message = "#{requester} requires #{dependency} but it conflicted:\n" + + @conflicts.each do |_, conflict| + message << conflict.explanation + end + + message + end + + def dependency + @request.dependency + end + +end + +class Gem::InstallError < Gem::Exception; end + +## +# Potentially raised when a specification is validated. +class Gem::InvalidSpecificationException < Gem::Exception; end + +class Gem::OperationNotSupportedError < Gem::Exception; end + +## +# Signals that a remote operation cannot be conducted, probably due to not +# being connected (or just not finding host). +#-- +# TODO: create a method that tests connection to the preferred gems server. +# All code dealing with remote operations will want this. Failure in that +# method should raise this error. +class Gem::RemoteError < Gem::Exception; end + +class Gem::RemoteInstallationCancelled < Gem::Exception; end + +class Gem::RemoteInstallationSkipped < Gem::Exception; end + +## +# Represents an error communicating via HTTP. +class Gem::RemoteSourceException < Gem::Exception; end + +## +# Raised when a gem dependencies file specifies a ruby version that does not +# match the current version. + +class Gem::RubyVersionMismatch < Gem::Exception; end + +## +# Raised by Gem::Validator when something is not right in a gem. + +class Gem::VerificationError < Gem::Exception; end + +## +# Raised to indicate that a system exit should occur with the specified +# exit_code + +class Gem::SystemExitException < SystemExit + + ## + # The exit code for the process + + attr_accessor :exit_code + + ## + # Creates a new SystemExitException with the given +exit_code+ + + def initialize(exit_code) + @exit_code = exit_code + + super "Exiting RubyGems with exit_code #{exit_code}" + end + +end + +## +# Raised by Resolver when a dependency requests a gem for which +# there is no spec. + +class Gem::UnsatisfiableDependencyError < Gem::DependencyError + + ## + # The unsatisfiable dependency. This is a + # Gem::Resolver::DependencyRequest, not a Gem::Dependency + + attr_reader :dependency + + ## + # Errors encountered which may have contributed to this exception + + attr_accessor :errors + + ## + # Creates a new UnsatisfiableDependencyError for the unsatisfiable + # Gem::Resolver::DependencyRequest +dep+ + + def initialize dep, platform_mismatch=nil + if platform_mismatch and !platform_mismatch.empty? + plats = platform_mismatch.map { |x| x.platform.to_s }.sort.uniq + super "Unable to resolve dependency: No match for '#{dep}' on this platform. Found: #{plats.join(', ')}" + else + if dep.explicit? + super "Unable to resolve dependency: user requested '#{dep}'" + else + super "Unable to resolve dependency: '#{dep.request_context}' requires '#{dep}'" + end + end + + @dependency = dep + @errors = [] + end + + ## + # The name of the unresolved dependency + + def name + @dependency.name + end + + ## + # The Requirement of the unresolved dependency (not Version). + + def version + @dependency.requirement + end + +end + +## +# Backwards compatible typo'd exception class for early RubyGems 2.0.x + +Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError # :nodoc: + -- cgit v1.2.3