dhall 0.1.0 → 0.2.0

data/lib/dhall/normalize.rb

@@ -199,14 +199,7 @@ module Dhall
 
 		class TextConcatenate
 			def normalize
-				normalized = super
-				if normalized.lhs == Text.new(value: "")
-					normalized.rhs
-				elsif normalized.rhs == Text.new(value: "")
-					normalized.lhs
-				else
-					normalized.lhs << normalized.rhs
-				end
+				TextLiteral.for(lhs, rhs).normalize
 			end
 		end
 
@@ -362,16 +355,6 @@ module Dhall
 		end
 	end
 
-	class Number
-	end
-
-	class Natural; end
-	class Integer; end
-	class Double; end
-
-	class Text
-	end
-
 	class TextLiteral
 		def normalize
 			TextLiteral.for(*super.flatten.chunks)
@@ -384,9 +367,6 @@ module Dhall
 		end
 	end
 
-	class Import
-	end
-
 	class LetIn
 		def normalize
 			desugar.normalize

data/lib/dhall/parser.citrus

@@ -9,11 +9,11 @@ end
 rule block_comment
 	(/(?:\u{7b})(?:\u{2d})/i (block_comment_continue))
 end
-rule block_comment_chunk
-	((block_comment) | /[\u{20}-@\u{5b}-\u{10ffff}]/i | (tab) | (end_of_line))
+rule block_comment_char
+	(/[\u{20}-@\u{5b}-\u{10ffff}]/i | (tab) | (end_of_line))
 end
 rule block_comment_continue
-	((/(?:\u{2d})(?:\u{7d})/i) | ((block_comment_chunk) (block_comment_continue)))
+	((/(?:\u{2d})(?:\u{7d})/i) | ((block_comment) (block_comment_continue)) | ((block_comment_char) (block_comment_continue)))
 end
 rule not_end_of_line
 	(/[\u{20}-@\u{5b}-\u{10ffff}]/i | (tab))
@@ -58,7 +58,7 @@ rule label
 	((/`/i (quoted_label) /`/i) | (simple_label)) <Dhall::Parser::Label>
 end
 rule nonreserved_label
-	(reserved_identifier simple_label_next_char+ | !reserved_identifier label) <Dhall::Parser::NonreservedLabel>
+	(builtin simple_label_next_char+ | !builtin label) <Dhall::Parser::NonreservedLabel>
 end
 rule any_label
 	(label)
@@ -135,6 +135,9 @@ end
 rule keyword
 	((if) | (then) | (else) | (let) | (in) | (using) | (missing) | (as) | (infinity) | (nan) | (merge) | (some))
 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>
+end
 rule optional
 	("Optional")
 end
@@ -144,6 +147,96 @@ end
 rule list
 	("List")
 end
+rule bool
+	("Bool")
+end
+rule true
+	("True")
+end
+rule false
+	("False")
+end
+rule none
+	("None")
+end
+rule natural
+	("Natural")
+end
+rule integer
+	("Integer")
+end
+rule double
+	("Double")
+end
+rule type
+	("Type")
+end
+rule kind
+	("Kind")
+end
+rule sort
+	("Sort")
+end
+rule natural_fold
+	("Natural" /\//i "f" "o" "l" "d")
+end
+rule natural_build
+	("Natural" /\//i "b" "u" "i" "l" "d")
+end
+rule natural_iszero
+	("Natural" /\//i "i" "s" "Z" "e" "r" "o")
+end
+rule natural_even
+	("Natural" /\//i "e" "v" "e" "n")
+end
+rule natural_odd
+	("Natural" /\//i "o" "d" "d")
+end
+rule natural_tointeger
+	("Natural" /\//i "t" "o" "I" "n" "t" "e" "g" "e" "r")
+end
+rule natural_show
+	("Natural" /\//i "s" "h" "o" "w")
+end
+rule integer_todouble
+	("Integer" /\//i "t" "o" "D" "o" "u" "b" "l" "e")
+end
+rule integer_show
+	("Integer" /\//i "s" "h" "o" "w")
+end
+rule double_show
+	("Double" /\//i "s" "h" "o" "w")
+end
+rule list_build
+	("List" /\//i "b" "u" "i" "l" "d")
+end
+rule list_fold
+	("List" /\//i "f" "o" "l" "d")
+end
+rule list_length
+	("List" /\//i "l" "e" "n" "g" "t" "h")
+end
+rule list_head
+	("List" /\//i "h" "e" "a" "d")
+end
+rule list_last
+	("List" /\//i "l" "a" "s" "t")
+end
+rule list_indexed
+	("List" /\//i "i" "n" "d" "e" "x" "e" "d")
+end
+rule list_reverse
+	("List" /\//i "r" "e" "v" "e" "r" "s" "e")
+end
+rule optional_fold
+	("Optional" /\//i "f" "o" "l" "d")
+end
+rule optional_build
+	("Optional" /\//i "b" "u" "i" "l" "d")
+end
+rule text_show
+	("Text" /\//i "s" "h" "o" "w")
+end
 rule combine
 	(/\u{2227}/i | (/(?:\/)(?:\u{5c})/i))
 end
@@ -184,7 +277,10 @@ rule integer_literal
 	(/[\u{2b}\u{2d}]/i (natural_literal)) <Dhall::Parser::IntegerLiteral>
 end
 rule identifier
-	((any_label) (((whsp) /@/i (whsp) (natural_literal))?)) <Dhall::Parser::Identifier>
+	((variable) | (builtin))
+end
+rule variable
+	((nonreserved_label) (((whsp) /@/i (whsp) (natural_literal))?)) <Dhall::Parser::Variable>
 end
 rule path_character
 	(/[!\u{24}-'\u{2a}\u{2b}\u{2d}\u{2e}0-;=@\u{5e}-z\u{7c}~]/i)
@@ -304,7 +400,7 @@ rule import
 	((import_hashed) (((whsp) (as) (whsp1) (text))?)) <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) (whsp) (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) ((empty_collection) | (non_empty_optional))) | (annotated_expression)) <Dhall::Parser::Expression>
 end
 rule annotated_expression
 	((operator_expression) (((whsp) `:` (whsp1) (expression))?)) <Dhall::Parser::AnnotatedExpression>
@@ -358,7 +454,10 @@ rule not_equal_expression
 	((application_expression) (((whsp) /(?:!)(?:=)/i (whsp) (application_expression))*)) <Dhall::Parser::NotEqualExpression>
 end
 rule application_expression
-	((((some) (whsp1))?) (import_expression) (((whsp1) (import_expression))*)) <Dhall::Parser::ApplicationExpression>
+	((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>
 end
 rule import_expression
 	((import) | (selector_expression))
@@ -462,39 +561,4 @@ end
 rule wsp
 	((sp) | (htab))
 end
-rule reserved_identifier
-	"Natural/build" |
-	"Natural/fold" |
-	"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" |
-	"Optional" |
-	"Natural" |
-	"Integer" |
-	"Double" |
-	"Text" |
-	"List" |
-	"True" |
-	"False" |
-	"None" |
-	"Type" |
-	"Kind" |
-	"Sort"
-end
 end

data/lib/dhall/parser.rb

@@ -109,14 +109,36 @@ 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
+					)
+				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
@@ -139,11 +161,23 @@ module Dhall
 		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
@@ -284,18 +318,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
 

data/lib/dhall/resolve.rb

@@ -20,7 +20,18 @@ module Dhall
 			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)
@@ -31,7 +42,11 @@ module Dhall
 				r = Net::HTTP.start(
 					uri.hostname,
 					uri.port,
-					use_ssl: uri.scheme == "https"
+					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"
@@ -46,6 +61,7 @@ module Dhall
 			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|
@@ -54,7 +70,11 @@ module Dhall
 					r = Net::HTTP.start(
 						uri.hostname,
 						uri.port,
-						use_ssl: uri.scheme == "https"
+						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"
@@ -63,6 +83,18 @@ module Dhall
 			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))
@@ -89,7 +121,7 @@ module Dhall
 			def call(sources)
 				@path_reader.call(sources).map.with_index do |promise, idx|
 					source = sources[idx]
-					if source.is_a?(Import::AbsolutePath) &&
+					if source.canonical.is_a?(Import::AbsolutePath) &&
 					   ["ipfs", "ipns"].include?(source.path.first)
 						gateway_fallback(source, promise)
 					else
@@ -117,17 +149,67 @@ module Dhall
 			end
 		end
 
+		module NoCache
+			def self.fetch(*)
+				yield
+			end
+		end
+
+		class RamCache
+			def initialize
+				@cache = {}
+			end
+
+			def fetch(key, &block)
+				return @cache[key] if @cache.key?(key)
+
+				Promise.resolve(nil).then(&block).then do |result|
+					@cache[key] = result
+				end
+			end
+		end
+
+		class StandardFileCache
+			def initialize(
+				dir=Pathname.new(ENV.fetch(
+					"XDG_CACHE_HOME", ENV.fetch("HOME") + "/.cache/"
+				)) + "dhall/"
+			)
+				dir.mkpath
+				@dir = dir
+				@ram = RamCache.new
+			end
+
+			def fetch(key, &block)
+				if key.is_a?(String) && key.start_with?("sha256:")
+					file = @dir + key.sub(/^sha256:/, "")
+					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) }
+						result
+					end
+				else
+					@ram.fetch(key, &block)
+				end
+			end
+		end
+
 		class ResolutionSet
-			def initialize(reader)
+			def initialize(reader, max_depth:)
 				@reader = reader
+				@max_depth = max_depth
 				@parents = []
 				@set = Hash.new { |h, k| h[k] = [] }
 			end
 
 			def register(source)
 				p = Promise.new
-				if @parents.include?(source)
+				if @parents.include?(source.canonical)
 					p.reject(ImportLoopException.new(source))
+				elsif @parents.length + 1 > @max_depth
+					msg = "Max import depth of #{@max_depth} exceeded"
+					p.reject(ImportFailedException.new(msg))
 				else
 					@set[source] << p
 				end
@@ -141,6 +223,8 @@ module Dhall
 
 			def reader
 				lambda do |sources|
+					raise TimeoutException if sources.any? { |s| s.deadline.exceeded? }
+
 					if @reader.arity == 2
 						@reader.call(sources, @parents.last&.origin || "localhost")
 					else
@@ -159,28 +243,66 @@ module Dhall
 			end
 		end
 
+		class SourceWithDeadline < SimpleDelegator
+			attr_reader :deadline
+
+			def initialize(source, deadline)
+				@source = source
+				@deadline = deadline
+
+				super(source)
+			end
+
+			def to_uri(*args)
+				self.class.new(super, deadline)
+			end
+		end
+
 		class Standard
+			attr_reader :deadline
+
 			def initialize(
 				path_reader: ReadPathSources,
-				http_reader: ReadHttpSources,
-				https_reader: http_reader
+				http_reader: StandardReadHttpSources,
+				https_reader: http_reader,
+				environment_reader: ReadEnvironmentSources,
+				cache: StandardFileCache.new,
+				max_depth: Float::INFINITY
 			)
-				@path_resolutions = ResolutionSet.new(path_reader)
-				@http_resolutions = ResolutionSet.new(http_reader)
-				@https_resolutions = ResolutionSet.new(https_reader)
-				@cache = {}
+				@path_resolutions = ResolutionSet.new(path_reader, max_depth: max_depth)
+				@http_resolutions = ResolutionSet.new(http_reader, max_depth: max_depth)
+				@https_resolutions = ResolutionSet.new(https_reader, max_depth: max_depth)
+				@env_resolutions = ResolutionSet.new(
+					environment_reader, max_depth: max_depth
+				)
+				@deadline = Util::NoDeadline.new
+				@cache = cache
+			end
+
+			def with_deadline(deadline)
+				dup.tap do |c|
+					c.instance_eval do
+						@deadline = deadline
+					end
+				end
 			end
 
 			def cache_fetch(key, &fallback)
 				@cache.fetch(key) do
-					Promise.resolve(nil).then(&fallback).then do |result|
-						@cache[key] = result
-					end
+					Promise.resolve(nil).then(&fallback)
 				end
 			end
 
 			def resolve_path(path_source)
-				@path_resolutions.register(path_source)
+				@path_resolutions.register(
+					SourceWithDeadline.new(path_source, @deadline)
+				)
+			end
+
+			def resolve_environment(env_source)
+				@env_resolutions.register(
+					SourceWithDeadline.new(env_source, @deadline)
+				)
 			end
 
 			def resolve_http(http_source)
@@ -188,8 +310,9 @@ module Dhall
 					resolver:    self,
 					relative_to: Dhall::Import::RelativePath.new
 				).then do |headers|
+					source = http_source.with(headers: headers.normalize)
 					@http_resolutions.register(
-						http_source.with(headers: headers.normalize)
+						SourceWithDeadline.new(source, @deadline)
 					)
 				end
 			end
@@ -199,8 +322,9 @@ module Dhall
 					resolver:    self,
 					relative_to: Dhall::Import::RelativePath.new
 				).then do |headers|
+					source = https_source.with(headers: headers.normalize)
 					@https_resolutions.register(
-						https_source.with(headers: headers.normalize)
+						SourceWithDeadline.new(source, @deadline)
 					)
 				end
 			end
@@ -208,6 +332,7 @@ module Dhall
 			def finish!
 				[
 					@path_resolutions,
+					@env_resolutions,
 					@http_resolutions,
 					@https_resolutions
 				].each do |rset|
@@ -220,6 +345,7 @@ module Dhall
 				dup.tap do |c|
 					c.instance_eval do
 						@path_resolutions = @path_resolutions.child(parent_source)
+						@env_resolutions = @env_resolutions.child(parent_source)
 						@http_resolutions = @http_resolutions.child(parent_source)
 						@https_resolutions = @https_resolutions.child(parent_source)
 					end
@@ -232,27 +358,36 @@ module Dhall
 				path_reader: ReadPathSources,
 				http_reader: ReadHttpSources,
 				https_reader: http_reader,
-				ipfs_public_gateway: "cloudflare-ipfs.com"
+				environment_reader: ReadEnvironmentSources,
+				ipfs_public_gateway: "cloudflare-ipfs.com",
+				cache: RamCache.new,
+				max_depth: 50
 			)
 				super(
-					path_reader:  ReadPathAndIPFSSources.new(
+					path_reader: ReadPathAndIPFSSources.new(
 						path_reader:    path_reader,
 						http_reader:    http_reader,
 						https_reader:   https_reader,
 						public_gateway: ipfs_public_gateway
 					),
-					http_reader:  http_reader,
-					https_reader: https_reader
+					http_reader: http_reader, https_reader: https_reader, cache: cache,
+					environment_reader: environment_reader, max_depth: max_depth
 				)
 			end
 		end
 
 		class LocalOnly < Standard
-			def initialize(path_reader: ReadPathSources)
+			def initialize(
+				path_reader: ReadPathSources,
+				environment_reader: ReadEnvironmentSources,
+				max_depth: 50
+			)
 				super(
-					path_reader:  path_reader,
-					http_reader:  RejectSources,
-					https_reader: RejectSources
+					path_reader:        path_reader,
+					environment_reader: environment_reader,
+					http_reader:        RejectSources,
+					https_reader:       RejectSources,
+					max_depth:          max_depth
 				)
 			end
 		end
@@ -260,9 +395,10 @@ module Dhall
 		class None < Default
 			def initialize
 				super(
-					path_reader:  RejectSources,
-					http_reader:  RejectSources,
-					https_reader: RejectSources
+					path_reader:        RejectSources,
+					environment_reader: RejectSources,
+					http_reader:        RejectSources,
+					https_reader:       RejectSources
 				)
 			end
 		end
@@ -305,7 +441,7 @@ 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).resolve(
+					@expr.parse_and_check(result, deadline: resolver.deadline).resolve(
 						resolver:    resolver.child(real_path),
 						relative_to: real_path
 					)
@@ -316,9 +452,15 @@ module Dhall
 		class FallbackResolver < ExpressionResolver
 			register_for Operator::ImportFallback
 
-			def resolve(**kwargs)
-				ExpressionResolver.for(@expr.lhs).resolve(**kwargs).catch do
-					ExpressionResolver.for(@expr.rhs).resolve(**kwargs)
+			def resolve(resolver:, relative_to:)
+				ExpressionResolver.for(@expr.lhs).resolve(
+					resolver:    resolver,
+					relative_to: relative_to
+				).catch do
+					@expr.rhs.resolve(
+						resolver:    resolver.child(Import::MissingImport.new),
+						relative_to: relative_to
+					)
 				end
 			end
 		end