Class: Object (Ruby 2.7.2)
Description: Class : Object - Ruby 2.7.2

### Home Classes Methods

### In Files

- digest/digest_conf.rb
- digest/lib/digest.rb

### Parent

BasicObject

### Methods

- #Digest
- #digest_conf
- #find_openssl_library

### Class/Module Index

Quicksearch

- Digest
- Digest::Base
- Digest::Class
- Digest::Instance
- Digest::MD5
- Digest::RMD160
- Digest::SHA1
- Digest::SHA2
- Object

No matching classes.

# Object

### Public Instance Methods

Digest(name) → digest_subclass click to toggle source

Returns a Digest subclass by `name` in a thread-safe manner even when on-demand loading is involved.

    require 'digest'

    Digest("MD5")
    # => Digest::MD5

    Digest(:SHA256)
    # => Digest::SHA256

    Digest(:Foo)
    # => LoadError: library not found for class Digest::Foo -- digest/foo

                   # File digest/lib/digest.rb, line 96
    def Digest(name)
      const = name.to_sym
      Digest::REQUIRE_MUTEX.synchronize {
        # Ignore autoload's because it is void when we have #const_missing
        Digest.const_missing(const)
      }
    rescue LoadError
      # Constants do not necessarily rely on digest/*.
      if Digest.const_defined?(const)
        Digest.const_get(const)
      else
        raise
      end
    end

digest_conf(name, hdr = name, funcs = nil, types = nil) click to toggle source

                   # File digest/digest_conf.rb, line 54
    def digest_conf(name, hdr = name, funcs = nil, types = nil)
      unless with_config("bundled-#{name}")
        cc = with_config("common-digest")
        if cc == true or /\b#{name}\b/ =~ cc
          if File.exist?("#$srcdir/#{name}cc.h") and
            have_header("CommonCrypto/CommonDigest.h")
            $defs << "-D#{name.upcase}_USE_COMMONDIGEST"
            $headers << "#{name}cc.h"
            return :commondigest
          end
        end

        dir_config("openssl")
        pkg_config("openssl")
        require File.expand_path('../../openssl/deprecation', __FILE__)
        if find_openssl_library
          funcs ||= name.upcase
          funcs = Array(funcs)
          types ||= funcs
          hdr = "openssl/#{hdr}.h"
          if funcs.all? {|func| OpenSSL.check_func("#{func}_Transform", hdr)} &&
             types.all? {|type| have_type("#{type}_CTX", hdr)}
            $defs << "-D#{name.upcase}_USE_OPENSSL"
            $headers << "#{name}ossl.h"
            return :ossl
          end
        end
      end
      $objs << "#{name}.#{$OBJEXT}"
      return
    end

find_openssl_library() click to toggle source

Copy from ext/openssl/extconf.rb

                   # File digest/digest_conf.rb, line 4
    def find_openssl_library
      if $mswin || $mingw
        # required for static OpenSSL libraries
        have_library("gdi32") # OpenSSL <= 1.0.2 (for RAND_screen())
        have_library("crypt32")
      end

      return false unless have_header("openssl/ssl.h")

      ret = have_library("crypto", "CRYPTO_malloc") &&
        have_library("ssl", "SSL_new")
      return ret if ret

      if $mswin
        # OpenSSL >= 1.1.0: libcrypto.lib and libssl.lib.
        if have_library("libcrypto", "CRYPTO_malloc") &&
            have_library("libssl", "SSL_new")
          return true
        end

        # OpenSSL <= 1.0.2: libeay32.lib and ssleay32.lib.
        if have_library("libeay32", "CRYPTO_malloc") &&
            have_library("ssleay32", "SSL_new")
          return true
        end

        # LibreSSL: libcrypto-##.lib and libssl-##.lib, where ## is the ABI version
        # number. We have to find the version number out by scanning libpath.
        libpath = $LIBPATH.dup
        libpath |= ENV["LIB"].split(File::PATH_SEPARATOR)
        libpath.map! { |d| d.tr(File::ALT_SEPARATOR, File::SEPARATOR) }

        ret = [
          ["crypto", "CRYPTO_malloc"],
          ["ssl", "SSL_new"]
        ].all? do |base, func|
          result = false
          libs = ["lib#{base}-[0-9][0-9]", "lib#{base}-[0-9][0-9][0-9]"]
          libs = Dir.glob(libs.map{|l| libpath.map{|d| File.join(d, l + ".*")}}.flatten).map{|path| File.basename(path, ".*")}.uniq
          libs.each do |lib|
            result = have_library(lib, func)
            break if result
          end
          result
        end
        return ret if ret
      end
      return false
    end