dhall 0.3.0 → 0.4.0

data/lib/dhall/coder.rb

@@ -105,7 +105,12 @@ module Dhall
 
 			refine List do
 				def to_ruby(&decode)
-					to_a.map(&decode)
+					arr = to_a.map(&decode)
+					unless element_type.is_a?(RecordType) &&
+					       element_type.keys == ["mapKey", "mapValue"]
+						return arr
+					end
+					Hash[arr.map { |h| h.values_at("mapKey", "mapValue") }]
 				end
 			end
 

data/lib/dhall/normalize.rb

@@ -51,7 +51,7 @@ module Dhall
 			normalized = super
 			return normalized.fuse if normalized.fuse
 
-			if normalized.function.is_a?(Builtin) ||
+			if normalized.function.is_a?(BuiltinFunction) ||
 			   normalized.function.is_a?(Function) ||
 			   normalized.function.is_a?(RecordSelection)
 				return normalized.function.call(normalized.argument)
@@ -120,7 +120,7 @@ module Dhall
 		end
 	end
 
-	class FunctionProxy
+	class FunctionProxyRaw
 		def shift(*)
 			self
 		end
@@ -245,7 +245,7 @@ module Dhall
 
 	class EmptyList
 		def normalize
-			super.with(element_type: element_type.normalize)
+			super.with(type: type.normalize)
 		end
 	end
 
@@ -265,6 +265,20 @@ module Dhall
 		end
 	end
 
+	class ToMap
+		def normalize
+			normalized = super
+			unless [Record, EmptyRecord].include?(normalized.record.class)
+				return normalized
+			end
+
+			List.of(*normalized.record.to_h.to_a.map do |(k, v)|
+				k = Text.new(value: k)
+				Record.new(record: { "mapKey" => k, "mapValue" => v })
+			end, type: normalized.type&.argument)
+		end
+	end
+
 	class Merge
 		def normalize
 			normalized = super
@@ -316,7 +330,19 @@ module Dhall
 
 	class RecordProjection
 		def normalize
-			record.normalize.slice(*selectors)
+			record.normalize.slice(*selectors.sort)
+		end
+	end
+
+	class RecordProjectionByExpression
+		def normalize
+			sel = selector.normalize
+
+			if sel.is_a?(RecordType)
+				RecordProjection.for(record, sel.keys).normalize
+			else
+				with(record: record.normalize, selector: sel)
+			end
 		end
 	end
 

data/lib/dhall/parser.citrus

@@ -1,7 +1,10 @@
 grammar Dhall::Parser::CitrusParser
 	root complete_expression
 rule end_of_line
-	(/\n/i | (/(?:\r)(?:\n)/i))
+	(/\n/i | (/(?:\r)(?:\n)/i)) <Dhall::Parser::EndOfLine>
+end
+rule valid_non_ascii
+	(/[\u{80}-\u{d7ff}\u{e000}-\u{fffd}\u{10000}-\u{1fffd}\u{20000}-\u{2fffd}\u{30000}-\u{3fffd}\u{40000}-\u{4fffd}\u{50000}-\u{5fffd}\u{60000}-\u{6fffd}\u{70000}-\u{7fffd}\u{80000}-\u{8fffd}\u{90000}-\u{9fffd}\u{a0000}-\u{afffd}\u{b0000}-\u{bfffd}\u{c0000}-\u{cfffd}\u{d0000}-\u{dfffd}\u{e0000}-\u{efffd}\u{f0000}-\u{ffffd}\u{100000}-\u{10fffd}]/i)
 end
 rule tab
 	(/\t/i)
@@ -10,13 +13,13 @@ rule block_comment
 	(/(?:\u{7b})(?:\u{2d})/i (block_comment_continue))
 end
 rule block_comment_char
-	!("{-" | "-}") (/[\u{20}-@\u{5b}-\u{10ffff}]/i | (tab) | (end_of_line))
+	!("{-" | "-}") (/[\u{20}-@\u{5b}-\u{7f}]/i | (valid_non_ascii) | (tab) | (end_of_line))
 end
 rule block_comment_continue
 	("-}" | block_comment_char+ block_comment_continue | (block_comment block_comment_continue))
 end
 rule not_end_of_line
-	(/[\u{20}-@\u{5b}-\u{10ffff}]/i | (tab))
+	(/[\u{20}-@\u{5b}-\u{7f}]/i | (valid_non_ascii) | (tab))
 end
 rule line_comment
 	(/(?:\u{2d})(?:\u{2d})/i ((not_end_of_line)*) (end_of_line))
@@ -36,6 +39,9 @@ end
 rule digit
 	(/\d/i)
 end
+rule alphanum
+	((alpha) | (digit))
+end
 rule hexdig
 	((digit) | /[a-f]/i | (digit) | /[a-f]/i)
 end
@@ -43,7 +49,7 @@ rule simple_label_first_char
 	((alpha) | `_`)
 end
 rule simple_label_next_char
-	((alpha) | (digit) | /[\u{2d}\/_]/i)
+	((alphanum) | /[\u{2d}\/_]/i)
 end
 rule simple_label
 	(keyword simple_label_next_char+ | !keyword (simple_label_first_char simple_label_next_char*))
@@ -67,10 +73,13 @@ rule double_quote_chunk
 	((interpolation) | (/\u{5c}/i (double_quote_escaped)) | (double_quote_char)) <Dhall::Parser::DoubleQuoteChunk>
 end
 rule double_quote_escaped
-	(/["\u{24}\/\u{5c}bfnrt]/ | ("u" ((hexdig) 4*4))) <Dhall::Parser::DoubleQuoteEscaped>
+	(/["\u{24}\/\u{5c}bfnrt]/ | ("u" (unicode_escape))) <Dhall::Parser::DoubleQuoteEscaped>
+end
+rule unicode_escape
+	(((hexdig) 4*4) | (/\u{7b}/i ((hexdig)+) /\u{7d}/i))
 end
 rule double_quote_char
-	(/[\u{20}!\u{23}-@\u{5b}\u{5d}-\u{10ffff}]/i)
+	(/[\u{20}!\u{23}-@\u{5b}\u{5d}-\u{7f}]/i | (valid_non_ascii))
 end
 rule double_quote_literal
 	(/"/i ((double_quote_chunk)*) /"/i) <Dhall::Parser::DoubleQuoteLiteral>
@@ -85,7 +94,7 @@ rule escaped_interpolation
 	(/(?:''(?:\u{24}))(?:\u{7b})/i) <Dhall::Parser::EscapedInterpolation>
 end
 rule single_quote_char
-	(/[\u{20}-@\u{5b}-\u{10ffff}]/i | (tab) | (end_of_line))
+	(/[\u{20}-@\u{5b}-\u{7f}]/i | (valid_non_ascii) | (tab) | (end_of_line))
 end
 rule single_quote_literal
 	(`''` (end_of_line) (single_quote_continue)) <Dhall::Parser::SingleQuoteLiteral>
@@ -132,8 +141,11 @@ end
 rule some
 	("Some")
 end
+rule tomap
+	("toMap")
+end
 rule keyword
-	((if) | (then) | (else) | (let) | (in) | (using) | (missing) | (as) | (infinity) | (nan) | (merge) | (some))
+	((if) | (then) | (else) | (let) | (in) | (using) | (missing) | (as) | (infinity) | (nan) | (merge) | (some) | (tomap))
 end
 rule builtin
 	((natural_fold) | (natural_build) | (natural_iszero) | (natural_even) | (natural_odd) | (natural_tointeger) | (natural_show) | (integer_todouble) | (integer_show) | (double_show) | (list_build) | (list_fold) | (list_length) | (list_head) | (list_last) | (list_indexed) | (list_reverse) | (optional_fold) | (optional_build) | (text_show) | (bool) | (true) | (false) | (optional) | (none) | (natural) | (integer) | (double) | (text) | (list) | (type) | (kind) | (sort)) <Dhall::Parser::Builtin>
@@ -147,6 +159,9 @@ end
 rule list
 	("List")
 end
+rule location
+	("Location")
+end
 rule bool
 	("Bool")
 end
@@ -286,7 +301,7 @@ rule path_character
 	(/[!\u{24}-'\u{2a}\u{2b}\u{2d}\u{2e}0-;=@\u{5e}-z\u{7c}~]/i)
 end
 rule quoted_path_character
-	(/[\u{20}!\u{23}-\u{2e}0-@\u{5b}-\u{10ffff}]/i)
+	(/[\u{20}!\u{23}-\u{2e}0-@\u{5b}-\u{7f}]/i | (valid_non_ascii))
 end
 rule unquoted_path_component
 	((path_character)+)
@@ -316,19 +331,22 @@ rule absolute_path
 	(path) <Dhall::Parser::AbsolutePath>
 end
 rule scheme
-	("http" ("s"?))
+	("http" ("s"?)) <Dhall::Parser::Scheme>
 end
 rule http_raw
-	((scheme) /(?::(?:\/))(?:\/)/i (authority) (path) ((/\u{3f}/i (query))?))
+	((scheme) /(?::(?:\/))(?:\/)/i (authority) (url_path) ((/\u{3f}/i (query))?))
+end
+rule url_path
+	(((path_component) | (/\//i (segment)))*) <Dhall::Parser::UrlPath>
 end
 rule authority
-	((((userinfo) /@/i)?) (host) ((`:` (port))?))
+	((((userinfo) /@/i)?) (host) ((`:` (port))?)) <Dhall::Parser::Authority>
 end
 rule userinfo
 	(((unreserved) | (pct_encoded) | (sub_delims) | `:`)*)
 end
 rule host
-	((ip_literal) | (ipv4address) | (reg_name))
+	((ip_literal) | (ipv4address) | (domain))
 end
 rule port
 	((digit)*)
@@ -354,8 +372,14 @@ end
 rule dec_octet
 	((/25(?:[0-5])/i) | (/2(?:[0-4])/i (digit)) | (`1` ((digit) 2*2)) | (/[1-9]/i (digit)) | (digit))
 end
-rule reg_name
-	(((unreserved) | (pct_encoded) | (sub_delims))*)
+rule domain
+	((domainlabel) ((/\u{2e}/i (domainlabel))*) (/\u{2e}/i?))
+end
+rule domainlabel
+	(((alphanum)+) (((/\u{2d}/i+) ((alphanum)+))*))
+end
+rule segment
+	((pchar)*)
 end
 rule pchar
 	((unreserved) | (pct_encoded) | (sub_delims) | /[:@]/i)
@@ -367,19 +391,19 @@ rule pct_encoded
 	(/%/i (hexdig) (hexdig))
 end
 rule unreserved
-	((alpha) | (digit) | /[\u{2d}\u{2e}_~]/i)
+	((alphanum) | /[\u{2d}\u{2e}_~]/i)
 end
 rule sub_delims
-	(/[!\u{24}&-,;=]/i)
+	(/[!\u{24}&'\u{2a}\u{2b};=]/i)
 end
 rule http
-	((http_raw) (((whsp) (using) (whsp1) ((import_hashed) | (/\u{28}/i (whsp) (import_hashed) (whsp) /\u{29}/i)))?)) <Dhall::Parser::Http>
+	((http_raw) (((whsp) (using) (whsp1) (import_expression))?)) <Dhall::Parser::Http>
 end
 rule env
 	(`env:` ((bash_environment_variable) | (/"/i (posix_environment_variable) /"/i))) <Dhall::Parser::Env>
 end
 rule bash_environment_variable
-	(((alpha) | `_`) (((alpha) | (digit) | `_`)*))
+	(((alpha) | `_`) (((alphanum) | `_`)*))
 end
 rule posix_environment_variable
 	((posix_environment_variable_character)+) <Dhall::Parser::PosixEnvironmentVariable>
@@ -397,10 +421,10 @@ rule import_hashed
 	((import_type) (((whsp1) (hash))?)) <Dhall::Parser::ImportHashed>
 end
 rule import
-	((import_hashed) (((whsp) (as) (whsp1) (text))?)) <Dhall::Parser::Import>
+	((import_hashed) (((whsp) (as) (whsp1) ((text) | (location)))?)) <Dhall::Parser::Import>
 end
 rule expression
-	(((lambda) (whsp) /\u{28}/i (whsp) (nonreserved_label) (whsp) `:` (whsp1) (expression) (whsp) /\u{29}/i (whsp) (arrow) (whsp) (expression)) | ((if) (whsp1) (expression) (whsp) (then) (whsp1) (expression) (whsp) (else) (whsp1) (expression)) | (((let_binding)+) (in) (whsp1) (expression)) | ((forall) (whsp) /\u{28}/i (whsp) (nonreserved_label) (whsp) `:` (whsp1) (expression) (whsp) /\u{29}/i (whsp) (arrow) (whsp) (expression)) | ((operator_expression) (whsp) (arrow) (whsp) (expression)) | ((merge) (whsp1) (import_expression) (whsp1) (import_expression) (whsp) `:` (whsp1) (application_expression)) | (/\u{5b}/i (whsp) ((empty_collection) | (non_empty_optional))) | (annotated_expression)) <Dhall::Parser::Expression>
+	(((lambda) (whsp) /\u{28}/i (whsp) (nonreserved_label) (whsp) `:` (whsp1) (expression) (whsp) /\u{29}/i (whsp) (arrow) (whsp) (expression)) | ((if) (whsp1) (expression) (whsp) (then) (whsp1) (expression) (whsp) (else) (whsp1) (expression)) | (((let_binding)+) (in) (whsp1) (expression)) | ((forall) (whsp) /\u{28}/i (whsp) (nonreserved_label) (whsp) `:` (whsp1) (expression) (whsp) /\u{29}/i (whsp) (arrow) (whsp) (expression)) | ((operator_expression) (whsp) (arrow) (whsp) (expression)) | ((merge) (whsp1) (import_expression) (whsp1) (import_expression) (whsp) `:` (whsp1) (application_expression)) | (/\u{5b}/i (whsp) /\u{5d}/i (whsp) `:` (whsp1) (application_expression)) | ((tomap) (whsp1) (import_expression) (whsp) `:` (whsp1) (application_expression)) | (annotated_expression)) <Dhall::Parser::Expression>
 end
 rule annotated_expression
 	((operator_expression) (((whsp) `:` (whsp1) (expression))?)) <Dhall::Parser::AnnotatedExpression>
@@ -408,12 +432,6 @@ end
 rule let_binding
 	((let) (whsp1) (nonreserved_label) (whsp) ((`:` (whsp1) (expression) (whsp))?) /=/i (whsp) (expression) (whsp)) <Dhall::Parser::LetBinding>
 end
-rule empty_collection
-	(/\u{5d}/i (whsp) `:` (whsp1) ((list) | (optional)) (whsp) (import_expression)) <Dhall::Parser::EmptyCollection>
-end
-rule non_empty_optional
-	((expression) (whsp) /\u{5d}/i (whsp) `:` (whsp1) (optional) (whsp) (import_expression)) <Dhall::Parser::NonEmptyOptional>
-end
 rule operator_expression
 	(import_alt_expression)
 end
@@ -457,7 +475,7 @@ rule application_expression
 	((first_application_expression) (((whsp1) (import_expression))*)) <Dhall::Parser::ApplicationExpression>
 end
 rule first_application_expression
-	(((merge) (whsp1) (import_expression) (whsp1) (import_expression)) | ((some) (whsp1) (import_expression)) | (import_expression)) <Dhall::Parser::FirstApplicationExpression>
+	(((merge) (whsp1) (import_expression) (whsp1) (import_expression)) | ((some) (whsp1) (import_expression)) | ((tomap) (whsp1) (import_expression)) | (import_expression)) <Dhall::Parser::FirstApplicationExpression>
 end
 rule import_expression
 	((import) | (selector_expression))
@@ -466,10 +484,13 @@ rule selector_expression
 	((primitive_expression) (((whsp) /\u{2e}/i (whsp) (selector))*)) <Dhall::Parser::SelectorExpression>
 end
 rule selector
-	((any_label) | (labels))
+	((any_label) | (labels) | (type_selector)) <Dhall::Parser::Selector>
 end
 rule labels
-	(/\u{7b}/i (whsp) (((any_label) (whsp) ((/,/i (whsp) (any_label) (whsp))*))?) /\u{7d}/i) <Dhall::Parser::Labels>
+	(/\u{7b}/i (whsp) (((any_label) (whsp) ((/,/i (whsp) (any_label) (whsp))*))?) /\u{7d}/i)
+end
+rule type_selector
+	(/\u{28}/i (whsp) (expression) (whsp) /\u{29}/i)
 end
 rule primitive_expression
 	((double_literal) | (natural_literal) | (integer_literal) | (text_literal) | (/\u{7b}/i (whsp) (record_type_or_literal) (whsp) /\u{7d}/i) | (/</i (whsp) (union_type_or_literal) (whsp) />/i) | (non_empty_list_literal) | (identifier) | (/\u{28}/i (complete_expression) /\u{29}/i)) <Dhall::Parser::PrimitiveExpression>

data/lib/dhall/parser.rb

@@ -21,16 +21,13 @@ 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]
 					.find { |k| captures.key?(k) }
-				key ? capture(key).value : super
+
+				key ? public_send(key) : super
 			end
 
 			def let_binding
@@ -78,6 +75,17 @@ 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
 		end
 
 		OPERATORS = {
@@ -122,9 +130,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 +150,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 +162,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
+					string
+				end
 			end
 		end
 
@@ -237,7 +251,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,9 +280,34 @@ 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
@@ -276,10 +315,7 @@ module Dhall
 		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")
+				indent = Util.indent_size(chunks.join)
 
 				TextLiteral.for(
 					*chunks
@@ -295,6 +331,12 @@ module Dhall
 			end
 		end
 
+		module EndOfLine
+			def value
+				"\n"
+			end
+		end
+
 		module Interpolation
 			def value
 				capture(:complete_expression).value
@@ -459,25 +501,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 +529,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 +550,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 +581,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 +675,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