dhall 0.1.0 → 0.5.1

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(
@@ -109,22 +123,44 @@ module Dhall
 
 		module ApplicationExpression
 			def value
-				some = capture(:some) ? [Variable["Some"]] : []
-				els = some + captures(:import_expression).map(&:value)
+				first_expr = [capture(:first_application_expression).value]
+				els = first_expr + captures(:import_expression).map(&:value)
 				els.reduce do |f, arg|
 					Application.for(function: f, argument: arg)
 				end
 			end
 		end
 
+		module FirstApplicationExpression
+			def value
+				if captures.key?(:merge)
+					merge
+				elsif captures.key?(:some)
+					Optional.new(value: capture(:import_expression).value)
+				elsif captures.key?(:tomap)
+					ToMap.new(record: capture(:import_expression).value)
+				else
+					super
+				end
+			end
+
+			def merge
+				Merge.new(
+					record: captures(:import_expression)[0].value,
+					input:  captures(:import_expression)[1].value,
+					type:   nil
+				)
+			end
+		end
+
 		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
@@ -132,18 +168,36 @@ 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
 
 		module Label
+			module Quoted
+				def quoted?
+					true
+				end
+			end
+
+			module Unquoted
+				def quoted?
+					false
+				end
+			end
+
 			def value
 				if first.string == "`"
-					matches[1].string
+					matches[1].string.extend(Quoted)
 				else
-					string
+					string.extend(Unquoted)
 				end
 			end
 		end
@@ -203,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
@@ -232,24 +286,49 @@ 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
-				indent = chunks.join.split(/\n/, -1).map { |line|
-					line.match(/^( *|\t*)/).to_s.length
-				}.min
+				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
-					.chunk { |c| c != "\n" }
-					.flat_map { |(line, chunk)| line ? chunk[indent..-1] : chunk }
+						.chunk { |c| c != "\n" }
+						.flat_map { |(line, chunk)| line ? chunk[indent..-1] : chunk }
 				)
 			end
 		end
@@ -260,6 +339,12 @@ module Dhall
 			end
 		end
 
+		module EndOfLine
+			def value
+				"\n"
+			end
+		end
+
 		module Interpolation
 			def value
 				capture(:complete_expression).value
@@ -284,18 +369,21 @@ module Dhall
 			end
 		end
 
-		module Identifier
+		module Variable
 			def value
-				name = capture(:any_label).value
+				Dhall::Variable.new(
+					name:  capture(:nonreserved_label).value,
+					index: capture(:natural_literal)&.string.to_i
+				)
+			end
+		end
 
-				return Dhall::Bool.new(value: true) if name == "True"
-				return Dhall::Bool.new(value: false) if name == "False"
+		module Builtin
+			def value
+				return Dhall::Bool.new(value: true) if string == "True"
+				return Dhall::Bool.new(value: false) if string == "False"
 
-				Dhall::Builtins::ALL[name]&.new ||
-					Variable.new(
-						name:  name,
-						index: capture(:natural_literal)&.string.to_i
-					)
+				Dhall::Builtins[string.to_sym]
 			end
 		end
 
@@ -304,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
@@ -316,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(
@@ -351,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
 
@@ -421,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?
@@ -468,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
@@ -487,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
 
@@ -497,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
 
@@ -521,9 +579,9 @@ module Dhall
 			def value
 				Dhall::Import::EnvironmentVariable.new(
 					if captures.key?(:bash_environment_variable)
-						capture(:bash_environment_variable).string
+						capture(:bash_environment_variable).value
 					else
-						capture(:posix_environment_variable).value.encode("utf-8")
+						capture(:posix_environment_variable).value
 					end
 				)
 			end
@@ -531,12 +589,22 @@ module Dhall
 
 		module PosixEnvironmentVariable
 			def value
-				matches.map(&:value).join
+				matches.map(&:value).join.encode(Encoding::UTF_8)
 			end
 		end
 
 		module PosixEnvironmentVariableCharacter
-			ESCAPES = Dhall::Import::EnvironmentVariable::ESCAPES
+			ESCAPES = {
+				"\"" => "\"",
+				"\\" => "\\",
+				"a"  => "\a",
+				"b"  => "\b",
+				"f"  => "\f",
+				"n"  => "\n",
+				"r"  => "\r",
+				"t"  => "\t",
+				"v"  => "\v"
+			}.freeze
 
 			def value
 				if first&.string == "\\"
@@ -580,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