dhall 0.3.0 → 0.5.2

data/lib/dhall/parser.rb

@@ -21,23 +21,21 @@ module Dhall
 
 		module Expression
 			def value
-				key =
-					[:let_binding, :lambda, :forall, :arrow, :if, :merge]
-					.find { |k| captures.key?(k) }
-
-				return public_send(key) if key
+				return list if string =~ /\A\[\s*\]/
 
 				key =
-					[:empty_collection, :non_empty_optional]
+					[:let_binding, :lambda, :forall, :arrow, :if, :merge, :tomap, :assert]
 					.find { |k| captures.key?(k) }
-				key ? capture(key).value : super
+
+				key ? public_send(key) : super
 			end
 
 			def let_binding
-				LetBlock.for(
-					lets: captures(:let_binding).map(&:value),
-					body: capture(:expression).value
-				)
+				captures(:let_binding).reverse.reduce(
+					capture(:expression).value
+				) do |inside, let|
+					LetIn.new(let: let.value, body: inside)
+				end
 			end
 
 			def lambda
@@ -78,6 +76,21 @@ module Dhall
 					type:   capture(:application_expression)&.value
 				)
 			end
+
+			def list
+				EmptyList.new(type: capture(:application_expression).value)
+			end
+
+			def tomap
+				ToMap.new(
+					record: capture(:import_expression).value,
+					type:   capture(:application_expression).value
+				)
+			end
+
+			def assert
+				Assertion.new(type: capture(:expression).value)
+			end
 		end
 
 		OPERATORS = {
@@ -92,7 +105,8 @@ module Dhall
 			combine_types_expression: :RecursiveRecordTypeMerge,
 			times_expression:         :Times,
 			equal_expression:         :Equal,
-			not_equal_expression:     :NotEqual
+			not_equal_expression:     :NotEqual,
+			equivalent_expression:    :Equivalent
 		}.freeze
 
 		OPERATORS.to_a.zip(
@@ -122,9 +136,9 @@ module Dhall
 				if captures.key?(:merge)
 					merge
 				elsif captures.key?(:some)
-					Optional.new(
-						value: capture(:import_expression).value
-					)
+					Optional.new(value: capture(:import_expression).value)
+				elsif captures.key?(:tomap)
+					ToMap.new(record: capture(:import_expression).value)
 				else
 					super
 				end
@@ -142,11 +156,11 @@ module Dhall
 		module SelectorExpression
 			def value
 				record = capture(:primitive_expression).value
-				selectors = captures(:selector).map(&:value)
-				selectors.reduce(record) do |rec, sels|
+				captures(:selector).map(&:value).reduce(record) do |rec, sels|
 					if sels.is_a?(Array)
-						return EmptyRecordProjection.new(record: rec) if sels.empty?
-						RecordProjection.new(record: rec, selectors: sels)
+						RecordProjection.for(rec, sels)
+					elsif sels.is_a?(Dhall::Expression)
+						RecordProjectionByExpression.new(record: rec, selector: sels)
 					else
 						RecordSelection.new(record: rec, selector: sels)
 					end
@@ -154,9 +168,15 @@ module Dhall
 			end
 		end
 
-		module Labels
+		module Selector
 			def value
-				captures(:any_label).map(&:value)
+				if captures.key?(:type_selector)
+					capture(:expression).value
+				elsif captures.key?(:labels)
+					captures(:any_label).map(&:value)
+				else
+					super
+				end
 			end
 		end
 
@@ -237,7 +257,7 @@ module Dhall
 					.map(&:value)
 					.chunk { |s| s.is_a?(String) }
 					.flat_map do |(strs, group)|
-						strs ? group.map { |s| s.encode("UTF-16BE") }.join : group
+						strs ? group.join : group
 					end
 				)
 			end
@@ -266,20 +286,44 @@ module Dhall
 				"t"  => "\t"
 			}.freeze
 
+			NON_CHARACTERS = [
+				(0xD800..0xDFFF),
+				(0xFFFE..0xFFFF),
+				(0x1FFFE..0x1FFFF),
+				(0x2FFFE..0x2FFFF),
+				(0x3FFFE..0x3FFFF),
+				(0x4FFFE..0x4FFFF),
+				(0x5FFFE..0x5FFFF),
+				(0x6FFFE..0x6FFFF),
+				(0x7FFFE..0x7FFFF),
+				(0x8FFFE..0x8FFFF),
+				(0x9FFFE..0x9FFFF),
+				(0xAFFFE..0xAFFFF),
+				(0xBFFFE..0xBFFFF),
+				(0xCFFFE..0xCFFFF),
+				(0xDFFFE..0xDFFFF),
+				(0xEFFFE..0xEFFFF),
+				(0xFFFFE..0xFFFFF),
+				(0x10FFFE..0x10FFFF)
+			].freeze
+
 			def value
 				ESCAPES.fetch(string) do
-					[string[1..-1]].pack("H*").force_encoding("UTF-16BE")
+					code = string.sub(/\Au\{?([A-F0-9]+)\}?/, "\\1").to_i(16)
+					NON_CHARACTERS.each do |range|
+						raise Citrus::ParseError, input if range.include?(code)
+					end
+					[code].pack("U*")
 				end
 			end
 		end
 
 		module SingleQuoteLiteral
 			def value
-				chunks = capture(:single_quote_continue).value
-				raw = chunks.join
-				indent = raw.scan(/^[ \t]*(?=[^ \t\r\n])/).map(&:chars)
-				            .reduce(&Util.method(:longest_common_prefix)).length
-				indent = 0 if raw.end_with?("\n")
+				chunks = capture(:single_quote_continue).value.flat_map do |chunk|
+					chunk.is_a?(String) ? chunk.gsub(/\r\n/, "\n").chars : chunk
+				end
+				indent = Util.indent_size(chunks.join)
 
 				TextLiteral.for(
 					*chunks
@@ -295,6 +339,12 @@ module Dhall
 			end
 		end
 
+		module EndOfLine
+			def value
+				"\n"
+			end
+		end
+
 		module Interpolation
 			def value
 				capture(:complete_expression).value
@@ -342,7 +392,7 @@ module Dhall
 				key = [
 					:complete_expression,
 					:record_type_or_literal,
-					:union_type_or_literal
+					:union_type
 				].find { |k| captures.key?(k) }
 				key ? capture(key).value : super
 			end
@@ -354,31 +404,6 @@ module Dhall
 			end
 		end
 
-		module UnionTypeOrLiteralVariantType
-			def value(label)
-				rest = capture(:non_empty_union_type_or_literal)&.value
-				type = UnionType.new(
-					alternatives: { label => capture(:expression)&.value }
-				)
-				if rest.is_a?(Union)
-					rest.with(alternatives: type.merge(rest.alternatives))
-				else
-					rest ? type.merge(rest) : type
-				end
-			end
-		end
-
-		module UnionLiteralVariantValue
-			def value(label)
-				Union.new(
-					tag:          label,
-					value:        capture(:expression).value,
-					alternatives: captures(:union_type_entry).map(&:value)
-					              .reduce(UnionType.new(alternatives: {}), &:merge)
-				)
-			end
-		end
-
 		module UnionTypeEntry
 			def value
 				UnionType.new(
@@ -389,19 +414,9 @@ module Dhall
 			end
 		end
 
-		module NonEmptyUnionTypeOrLiteral
+		module NonEmptyUnionType
 			def value
-				key = [
-					:union_literal_variant_value,
-					:union_type_or_literal_variant_type
-				].find { |k| captures.key?(k) }
-
-				if key
-					capture(key).value(capture(:any_label).value)
-				else
-					no_alts = UnionType.new(alternatives: {})
-					Union.from(no_alts, capture(:any_label).value, nil)
-				end
+				captures(:union_type_entry).map(&:value).reduce(&:merge)
 			end
 		end
 
@@ -459,25 +474,6 @@ module Dhall
 
 		RecordTypeEntry = RecordLiteralEntry
 
-		module EmptyCollection
-			def value
-				if captures.key?(:list)
-					EmptyList.new(element_type: capture(:import_expression).value)
-				else
-					OptionalNone.new(value_type: capture(:import_expression).value)
-				end
-			end
-		end
-
-		module NonEmptyOptional
-			def value
-				Optional.new(
-					value:      capture(:expression).value,
-					value_type: capture(:import_expression).value
-				)
-			end
-		end
-
 		module AnnotatedExpression
 			def value
 				if matches[1].string.empty?
@@ -506,6 +502,8 @@ module Dhall
 			def value
 				import_type = if captures.key?(:text)
 					Dhall::Import::Text
+				elsif captures.key?(:location)
+					Dhall::Import::AsLocation
 				else
 					Dhall::Import::Expression
 				end
@@ -525,7 +523,28 @@ module Dhall
 		module Hash
 			def value
 				protocol, data = string.split(/:/, 2)
-				Dhall::Import::IntegrityCheck.new(protocol, data)
+				Dhall::Import::IntegrityCheck.new(
+					code:   Multihashes::TABLE.key(
+						protocol.sub(/\Asha(\d{3})/, "sha2-\\1")
+					),
+					digest: [data].pack("H*")
+				)
+			end
+		end
+
+		module Scheme
+			def value
+				::URI.scheme_list[string.upcase]
+			end
+		end
+
+		module Authority
+			def value
+				{
+					userinfo: capture(:userinfo)&.value,
+					host:     capture(:host).value,
+					port:     capture(:port)&.value
+				}
 			end
 		end
 
@@ -535,23 +554,24 @@ module Dhall
 				"https" => Dhall::Import::Https
 			}.freeze
 
+			def http(key)
+				@http ||= capture(:http_raw)
+				@http.capture(key)&.value
+			end
+
 			def value
-				http = capture(:http_raw)
-				SCHEME.fetch(http.capture(:scheme).value).new(
-					capture(:import_hashed)&.value(Dhall::Import::Expression),
-					http.capture(:authority).value,
-					*unescaped_components,
-					http.capture(:query)&.value
+				uri = http(:scheme).build(
+					http(:authority).merge(
+						path: http(:url_path) || "/"
+					)
 				)
-			end
 
-			def unescaped_components
-				capture(:http_raw)
-					.capture(:path)
-					.captures(:path_component)
-					.map do |pc|
-						pc.value(URI.method(:unescape))
-					end
+				uri.instance_variable_set(:@query, http(:query))
+
+				SCHEME.fetch(uri.scheme).new(
+					headers: capture(:import_expression)&.value,
+					uri:     uri
+				)
 			end
 		end
 
@@ -628,15 +648,28 @@ module Dhall
 		end
 
 		module PathComponent
-			def value(unescaper=:itself.to_proc)
+			def value(escaper=:itself.to_proc)
 				if captures.key?(:quoted_path_component)
-					capture(:quoted_path_component).value
+					escaper.call(capture(:quoted_path_component).value)
 				else
-					unescaper.call(capture(:unquoted_path_component).value)
+					capture(:unquoted_path_component).value
 				end
 			end
 		end
 
+		module UrlPath
+			def value
+				"/" + matches.map { |pc|
+					if pc.captures.key?(:path_component)
+						# We escape here because ruby stdlib URI just stores path unparsed
+						pc.value(Util.method(:uri_escape))
+					else
+						pc.string[1..-1]
+					end
+				}.join("/")
+			end
+		end
+
 		module Missing
 			def value
 				Dhall::Import::MissingImport.new

data/lib/dhall/resolve.rb

@@ -16,13 +16,13 @@ module Dhall
 	module Resolvers
 		ReadPathSources = lambda do |sources|
 			sources.map do |source|
-				Promise.resolve(nil).then { source.pathname.binread }
+				Util::LazyPromise.new { source.pathname.binread }
 			end
 		end
 
 		ReadEnvironmentSources = lambda do |sources|
 			sources.map do |source|
-				Promise.resolve(nil).then do
+				Util::LazyPromise.new do
 					ENV.fetch(source.var) do
 						raise ImportFailedException, "No #{source}"
 					end
@@ -38,16 +38,10 @@ module Dhall
 				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) }
+					source.headers.to_a.map { |h|
+						(h.fetch("header") { h.fetch("mapKey") }).to_s
+					}.join(",")
+				r = Util.net_http_req_with_timeout(uri, req, timeout: timeout)
 
 				raise ImportFailedException, source if r.code != "200"
 				unless r["Access-Control-Allow-Origin"] == parent_origin ||
@@ -59,23 +53,21 @@ module Dhall
 
 		ReadHttpSources = lambda do |sources, parent_origin|
 			sources.map do |source|
-				Promise.resolve(nil).then do
+				Util::LazyPromise.new 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
+					r = loop do
+						req = Net::HTTP::Get.new(uri)
+						source.headers.each do |header|
+							req[(header.fetch("header") { header.fetch("mapKey") }).to_s] =
+								(header.fetch("value") { header.fetch("mapValue") }).to_s
+						end
+						r = Util.net_http_req_with_timeout(uri, req, timeout: timeout)
+
+						break r unless ["301", "302", "303", "307", "308"].include?(r.code)
+						uri = URI(r["Location"])
 					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
@@ -86,7 +78,7 @@ module Dhall
 		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")
+					s = s.dup.force_encoding("UTF-8")
 					unless s.valid_encoding?
 						raise ImportFailedException, "#{s.inspect} is not valid UTF-8"
 					end
@@ -106,7 +98,7 @@ module Dhall
 				path_reader: ReadPathSources,
 				http_reader: ReadHttpSources,
 				https_reader: http_reader,
-				public_gateway: "cloudflare-ipfs.com"
+				public_gateway: URI("https://cloudflare-ipfs.com")
 			)
 				@path_reader = path_reader
 				@http_reader = http_reader
@@ -139,7 +131,7 @@ module Dhall
 			def gateway_fallback(source, promise)
 				promise.catch {
 					@http_reader.call([
-						source.to_uri(Import::Http, "localhost:8000")
+						source.to_uri(Import::Http, URI("http://localhost:8000"))
 					], "localhost").first
 				}.catch do
 					@https_reader.call([
@@ -182,11 +174,11 @@ module Dhall
 
 			def fetch(key, &block)
 				if key.is_a?(String) && key.start_with?("sha256:")
-					file = @dir + key.sub(/^sha256:/, "")
+					file = @dir + key.sub(/^sha256:/, "1220")
 					return Dhall.from_binary(file.binread) if file.exist?
 
 					Promise.resolve(nil).then(&block).then do |result|
-						file.open("wb") { |fh| fh.write(result.to_binary) }
+						file.open("wb") { |fh| fh.write(result.to_cbor) }
 						result
 					end
 				else
@@ -359,7 +351,7 @@ module Dhall
 				http_reader: ReadHttpSources,
 				https_reader: http_reader,
 				environment_reader: ReadEnvironmentSources,
-				ipfs_public_gateway: "cloudflare-ipfs.com",
+				ipfs_public_gateway: URI("https://cloudflare-ipfs.com"),
 				cache: RamCache.new,
 				max_depth: 50
 			)
@@ -427,9 +419,25 @@ module Dhall
 			).then { |h| @expr.with(h) }
 		end
 
+		class ImportAsLocationResolver < ExpressionResolver
+			def resolve(resolver:, relative_to:)
+				Promise.resolve(nil).then do
+					@expr.real_path(relative_to).location
+				end
+			end
+		end
+
 		class ImportResolver < ExpressionResolver
 			register_for Import
 
+			def self.new(expr)
+				if expr.import_type == Import::AsLocation
+					ImportAsLocationResolver.new(expr)
+				else
+					super
+				end
+			end
+
 			def resolve(resolver:, relative_to:)
 				Promise.resolve(nil).then do
 					resolver.cache_fetch(@expr.cache_key(relative_to)) do
@@ -441,7 +449,9 @@ module Dhall
 			def resolve_raw(resolver:, relative_to:)
 				real_path = @expr.real_path(relative_to)
 				real_path.resolve(resolver).then do |result|
-					@expr.parse_and_check(result, deadline: resolver.deadline).resolve(
+					@expr.parse_resolve_check(
+						result,
+						deadline:    resolver.deadline,
 						resolver:    resolver.child(real_path),
 						relative_to: real_path
 					)