Module: Dhall::Resolvers

Defined in:

lib/dhall/resolve.rb

Defined Under Namespace

Modules: NoCache Classes: Default, LocalOnly, None, RamCache, ReadPathAndIPFSSources, ResolutionSet, SourceWithDeadline, Standard, StandardFileCache

Constant Summary

ReadPathSources =

lambda do |sources|
  sources.map do |source|
    Promise.resolve(nil).then { source.pathname.binread }
  end
end

ReadEnvironmentSources =

lambda do |sources|
  sources.map do |source|
    Promise.resolve(nil).then do
      ENV.fetch(source.var) do
        raise ImportFailedException, "No #{source}"
      end
    end
  end
end

PreflightCORS =

lambda do |source, parent_origin|
  timeout = source.deadline.timeout
  uri = source.uri
  if parent_origin != "localhost" && parent_origin != source.origin
    req = Net::HTTP::Options.new(uri)
    req["Origin"] = parent_origin
    req["Access-Control-Request-Method"] = "GET"
    req["Access-Control-Request-Headers"] =
      source.headers.map { |h| h.fetch("header").to_s }.join(",")
    r = Net::HTTP.start(
      uri.hostname,
      uri.port,
      use_ssl:       uri.scheme == "https",
      open_timeout:  timeout,
      ssl_timeout:   timeout,
      read_timeout:  timeout,
      write_timeout: timeout
    ) { |http| http.request(req) }

    raise ImportFailedException, source if r.code != "200"
    unless r["Access-Control-Allow-Origin"] == parent_origin ||
           r["Access-Control-Allow-Origin"] == "*"
      raise ImportBannedException, source
    end
  end
end

ReadHttpSources =

lambda do |sources, parent_origin|
  sources.map do |source|
    Promise.resolve(nil).then do
      PreflightCORS.call(source, parent_origin)
      timeout = source.deadline.timeout
      uri = source.uri
      req = Net::HTTP::Get.new(uri)
      source.headers.each do |header|
        req[header.fetch("header").to_s] = header.fetch("value").to_s
      end
      r = Net::HTTP.start(
        uri.hostname,
        uri.port,
        use_ssl:       uri.scheme == "https",
        open_timeout:  timeout,
        ssl_timeout:   timeout,
        read_timeout:  timeout,
        write_timeout: timeout
      ) { |http| http.request(req) }

      raise ImportFailedException, source if r.code != "200"
      r.body
    end
  end
end

StandardReadHttpSources =

lambda do |sources, parent_origin|
  ReadHttpSources.call(sources, parent_origin).map do |source_promise|
    source_promise.then do |s|
      s = s.force_encoding("UTF-8")
      unless s.valid_encoding?
        raise ImportFailedException, "#{s.inspect} is not valid UTF-8"
      end
      s
    end
  end
end

RejectSources =

lambda do |sources|
  sources.map do |source|
    Promise.new.reject(ImportBannedException.new(source))
  end
end