dhall 0.3.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 30ff6e0ad066b23996b9a31b21e7f1a30b86b265
-  data.tar.gz: 88efb36ee05894a74df3b691d67774b8e0eea185
+SHA256:
+  metadata.gz: c6ba874fec536af3a57ea4a0ca59f040076ebc03ed639dcd44a5a2b79e8bf252
+  data.tar.gz: 4408343df3c63a8c96f6e191f3109a2110ae4b6f3ab06aee58c15b2e7439f6ef
 SHA512:
-  metadata.gz: ff197049f1d4ceb3e1742a4e3b44491192170c4bb1e32b7aef6bbaeb643f16b828ffdee1d78eaa628a9f0dd9d5dedd0f4c796556b2e72b92ed0705a0e8306430
-  data.tar.gz: e92aad6b3921f4bd25ebdf8f20204b95ceec8814250ed90b5424b70a75991ca68de8bd60b0c2cf982541c560f9e1ba135f87f0b05f685d767588150b051c465f
+  metadata.gz: e3fdb1ed15e039261aedfc608d612eb4739b7a0204aa26524d66e8999d14ed71cc4e2b5964077f88cf860a99454548c7c2aae2188de9a9687fb173e780441fe4
+  data.tar.gz: 0b9b101c0ccaec5d6be7bbfab0a3698c1eb81f91c06ba9efe663391ce56e8e71613fb0f4cd37af12cc68e7973278fcd9f47190d80a0369c14230a3e0480cdda1

data/bin/dhall-compile

@@ -13,19 +13,43 @@ def compile(source)
 		resolver: Dhall::Resolvers::Default.new(
 			max_depth: Float::INFINITY
 		)
-	).then(&:to_binary)
+	)
+end
+
+module FilenameWriter
+	def self.write(_, out, dhall)
+		warn out
+		out.dirname.mkpath
+		out.write(dhall.to_binary)
+	end
+end
+
+module CacheWriter
+	def self.write(output_directory, out, dhall)
+		base = "1220#{dhall.digest.hexdigest}"
+		out = out.dirname + base
+		if output_directory
+			out = output_directory + base
+			out.dirname.mkpath
+		end
+		warn out
+		out.write(dhall.to_cbor)
+	end
 end
 
 def compile_file(file_path, relative_to: Pathname.new("."))
+	$stderr.print "#{file_path} => "
 	out = file_path.sub_ext(@extension)
 	if @output_directory
 		out = @output_directory + out.relative_path_from(relative_to)
-		out.dirname.mkpath
 	end
-	warn "#{file_path} => #{out}"
-	compile(file_path.expand_path).then(&out.method(:write))
+	compile(file_path.expand_path).then do |dhall|
+		@writer.write(@output_directory, out, dhall)
+	end
 end
 
+@writer = FilenameWriter
+# rubocop:disable Metrics/BlockLength
 opt_parser = OptionParser.new do |opts|
 	opts.banner = "Usage: dhall-compile [options] [-] [files_and_dirs]"
 
@@ -45,11 +69,21 @@ opt_parser = OptionParser.new do |opts|
 		@extension = ext ? ".#{ext}" : ""
 	end
 
+	opts.on(
+		"-c",
+		"--cache",
+		"Write output in standard dhall file cache format"
+	) do
+		@extension = ""
+		@writer = CacheWriter
+	end
+
 	opts.on("-h", "--help", "Show this usage information") do
 		warn opts
 		exit
 	end
 end
+# rubocop:enable Metrics/BlockLength
 
 opt_parser.parse!
 

data/bin/json-to-dhall

@@ -5,4 +5,4 @@ require "dhall"
 require "json"
 using Dhall::AsDhall
 
-STDOUT.write(CBOR.encode(JSON.parse(STDIN.read).as_dhall))
+STDOUT.write(JSON.parse(STDIN.read).as_dhall.to_binary)

data/bin/yaml-to-dhall

@@ -5,4 +5,4 @@ require "dhall"
 require "yaml"
 using Dhall::AsDhall
 
-STDOUT.write(CBOR.encode(YAML.safe_load(STDIN.read, [Symbol]).as_dhall))
+STDOUT.write(YAML.safe_load(STDIN.read, [Symbol]).as_dhall.to_binary)

data/dhall.gemspec

@@ -25,12 +25,16 @@ Gem::Specification.new do |spec|
 	spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
 	spec.require_paths = ["lib"]
 
+	spec.add_dependency "base32", "~> 0.3.2"
 	spec.add_dependency "cbor", "~> 0.5.9.3"
 	spec.add_dependency "citrus", "~> 3.0"
+	spec.add_dependency "lazy_object", "~> 0.0.3"
+	spec.add_dependency "multihashes", "~> 0.2.0"
 	spec.add_dependency "promise.rb", "~> 0.7.4"
 	spec.add_dependency "value_semantics", "~> 3.0"
 
 	spec.add_development_dependency "abnf", "~> 0.0.1"
+	spec.add_development_dependency "minitest-fail-fast", "~> 0.1.0"
 	spec.add_development_dependency "simplecov", "~> 0.16.1"
 	spec.add_development_dependency "webmock", "~> 3.5"
 end

data/lib/dhall/as_dhall.rb

@@ -284,5 +284,11 @@ module Dhall
 				FunctionProxy.new(self)
 			end
 		end
+
+		refine ::Method do
+			def as_dhall
+				to_proc.as_dhall
+			end
+		end
 	end
 end

data/lib/dhall/ast.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "base32"
+require "lazy_object"
+require "multihashes"
 require "uri"
 require "value_semantics"
 
@@ -33,8 +36,7 @@ module Dhall
 		end
 
 		def *(other)
-			case other
-			when Natural
+			if other.is_a?(Natural) && other.zero?
 				other * self
 			else
 				Operator::Times.new(lhs: self, rhs: other)
@@ -68,7 +70,7 @@ module Dhall
 		def dhall_eq(other)
 			if self == other
 				Bool.new(value: true)
-			elsif other.is_a?(Bool)
+			elsif other == Bool.new(value: true)
 				other.dhall_eq(self)
 			else
 				Operator::Equal.new(lhs: self, rhs: other)
@@ -102,6 +104,10 @@ module Dhall
 			end
 		end
 
+		def annotate(type)
+			TypeAnnotation.new(value: self, type: type)
+		end
+
 		def to_s
 			inspect
 		end
@@ -128,7 +134,7 @@ module Dhall
 		def flatten
 			f, args = if function.is_a?(Application)
 				function.flatten
-			elsif function.is_a?(Builtin) &&
+			elsif function.is_a?(BuiltinFunction) &&
 			      (unfilled = function.unfill).is_a?(Application)
 				unfilled.flatten
 			else
@@ -216,7 +222,29 @@ module Dhall
 		end
 	end
 
-	class FunctionProxy < Function
+	class RubyObjectRaw < Expression
+		def initialize(object)
+			@object = object
+		end
+
+		def unwrap
+			@object
+		end
+
+		def respond_to_missing?(m)
+			super || @object.respond_to?(m)
+		end
+
+		def method_missing(m, *args, &block)
+			if @object.respond_to?(m)
+				@object.public_send(m, *args, &block)
+			else
+				super
+			end
+		end
+	end
+
+	class FunctionProxyRaw < Function
 		def initialize(callable, curry: true)
 			@callable = if !curry
 				callable
@@ -230,7 +258,7 @@ module Dhall
 		end
 
 		def call(*args, &block)
-			@callable.call(*args.map { |arg| arg&.as_dhall }, &block).as_dhall
+			RubyObjectRaw.new(@callable.call(*args.map { |arg| arg&.as_dhall }, &block))
 		end
 
 		def as_json
@@ -238,6 +266,12 @@ module Dhall
 		end
 	end
 
+	class FunctionProxy < FunctionProxyRaw
+		def call(*args, &block)
+			super.unwrap.as_dhall
+		end
+	end
+
 	class Bool < Expression
 		include(ValueSemantics.for_attributes do
 			value Bool()
@@ -317,6 +351,33 @@ module Dhall
 			[3, OPERATORS.index(self.class), lhs.as_json, rhs.as_json]
 		end
 
+		module FetchFromMerge
+			def fetch_second_record(first, second, selector)
+				rec = self.class.new(
+					self.class::FETCH2K => second.slice(selector),
+					self.class::FETCH1K => first
+				).normalize
+
+				if rec.class == self.class
+					RecordSelection.new(record: rec, selector: selector)
+				else
+					rec.fetch(selector)
+				end
+			end
+
+			def fetch(selector)
+				first = public_send(self.class::FETCH1K)
+				second = public_send(self.class::FETCH2K)
+				if first.is_a?(Record)
+					first.fetch(selector) { second.fetch(selector) }
+				elsif second.is_a?(Record)
+					fetch_second_record(first, second, selector)
+				else
+					super
+				end
+			end
+		end
+
 		class Or < Operator; end
 		class And < Operator; end
 		class Equal < Operator; end
@@ -325,17 +386,27 @@ module Dhall
 		class Times < Operator; end
 		class TextConcatenate < Operator; end
 		class ListConcatenate < Operator; end
-		class RecursiveRecordMerge < Operator; end
-		class RightBiasedRecordMerge < Operator; end
+		class RecursiveRecordMerge < Operator
+			FETCH1K = :lhs
+			FETCH2K = :rhs
+			include FetchFromMerge
+		end
+		class RightBiasedRecordMerge < Operator
+			FETCH1K = :rhs
+			FETCH2K = :lhs
+			include FetchFromMerge
+		end
 		class RecursiveRecordTypeMerge < Operator; end
 		class ImportFallback < Operator; end
+		class Equivalent < Operator; end
 
 		OPERATORS = [
 			Or, And, Equal, NotEqual,
 			Plus, Times,
 			TextConcatenate, ListConcatenate,
 			RecursiveRecordMerge, RightBiasedRecordMerge, RecursiveRecordTypeMerge,
-			ImportFallback
+			ImportFallback,
+			Equivalent
 		].freeze
 	end
 
@@ -344,9 +415,18 @@ module Dhall
 
 		include(ValueSemantics.for_attributes do
 			elements     Util::ArrayOf.new(Expression, min: 1)
-			element_type Either(nil, Expression), default: nil
+			type         Either(nil, Expression), default: nil
 		end)
 
+		def initialize(attrs)
+			if attrs.key?(:element_type)
+				et = attrs.delete(:element_type)
+				attrs[:type] = self.class.as_dhall.call(et) if et
+			end
+
+			super
+		end
+
 		def self.of(*args, type: nil)
 			if args.empty?
 				EmptyList.new(element_type: type)
@@ -359,11 +439,13 @@ module Dhall
 			Builtins[:List]
 		end
 
-		def type
-			Dhall::Application.new(
-				function: self.class.as_dhall,
-				argument: element_type
-			)
+		def element_type
+			if type.nil?
+			elsif type.is_a?(Application) && type.function == Builtins[:List]
+				type.argument
+			else
+				raise "Cannot get element_type of: #{type.inspect}"
+			end
 		end
 
 		def as_json
@@ -371,9 +453,10 @@ module Dhall
 		end
 
 		def map(type: nil, &block)
+			type = type.nil? ? nil : Builtins[:List].call(type.as_dhall)
 			with(
-				elements:     elements.each_with_index.map(&block),
-				element_type: type&.as_dhall
+				elements: elements.each_with_index.map(&block),
+				type:     type
 			)
 		end
 
@@ -421,11 +504,22 @@ module Dhall
 
 	class EmptyList < List
 		include(ValueSemantics.for_attributes do
-			element_type Either(nil, Expression)
+			type Either(nil, Expression)
 		end)
 
+		def initialize(attrs)
+			if attrs.key?(:element_type)
+				et = attrs.delete(:element_type)
+				attrs[:type] = self.class.as_dhall.call(et) if et
+			end
+
+			super
+		end
+
 		def as_json
 			[4, element_type.as_json]
+		rescue
+			[28, type.as_json]
 		end
 
 		def map(type: nil)
@@ -460,6 +554,10 @@ module Dhall
 			self
 		end
 
+		def join(*)
+			""
+		end
+
 		def concat(other)
 			other
 		end
@@ -547,7 +645,7 @@ module Dhall
 		include(ValueSemantics.for_attributes do
 			record Expression
 			input  Expression
-			type   Either(Expression, nil)
+			type   Either(Expression, nil), default: nil
 		end)
 
 		def as_json
@@ -556,6 +654,18 @@ module Dhall
 		end
 	end
 
+	class ToMap < Expression
+		include(ValueSemantics.for_attributes do
+			record Expression
+			type   Either(Expression, nil), default: nil
+		end)
+
+		def as_json
+			[27, record.as_json] +
+				(type.nil? ? [] : [type.as_json])
+		end
+	end
+
 	class RecordType < Expression
 		include(ValueSemantics.for_attributes do
 			record Util::HashOf.new(::String, Expression, min: 1)
@@ -793,11 +903,38 @@ module Dhall
 			selectors Util::ArrayOf.new(::String, min: 1)
 		end)
 
+		def self.for(record, selectors)
+			if selectors.empty?
+				EmptyRecordProjection.new(record: record)
+			else
+				new(record: record, selectors: selectors)
+			end
+		end
+
+		def fetch(selector)
+			record.fetch(selector)
+		end
+
 		def as_json
 			[10, record.as_json, *selectors]
 		end
 	end
 
+	class RecordProjectionByExpression < Expression
+		include(ValueSemantics.for_attributes do
+			record Expression
+			selector Expression
+		end)
+
+		def fetch(selector)
+			record.fetch(selector)
+		end
+
+		def as_json
+			[10, record.as_json, [selector.as_json]]
+		end
+	end
+
 	class EmptyRecordProjection < Expression
 		include(ValueSemantics.for_attributes do
 			record Expression
@@ -968,8 +1105,8 @@ module Dhall
 	class If < Expression
 		include(ValueSemantics.for_attributes do
 			predicate Expression
-			self.then Expression
-			self.else Expression
+			def_attr :then, Expression
+			def_attr :else, Expression
 		end)
 
 		def as_json
@@ -1189,91 +1326,92 @@ module Dhall
 	class Import < Expression
 		class IntegrityCheck
 			include(ValueSemantics.for_attributes do
-				protocol Either("sha256", :nocheck)
-				data     Either(::String, nil)
+				code   ::Integer
+				digest ::String
 			end)
 
 			class FailureException < StandardError; end
 
-			def initialize(protocol=:nocheck, data=nil)
-				super(
-					protocol: protocol,
-					data:     data
-				)
+			def to_s
+				"#{Multihashes::TABLE[code].sub(/\Asha2-/, "sha")}:#{hexdigest}"
 			end
 
-			def to_s
-				"#{@protocol}:#{@data}"
+			def hexdigest
+				digest.unpack("H*").first.encode(Encoding::UTF_8)
 			end
 
-			def check(expr)
-				return expr if @protocol == :nocheck
+			def ipfs
+				"/ipfs/b#{Base32.encode("\x01\x55" + as_json).downcase.sub(/=*$/, "")}"
+			end
 
+			def check(expr)
 				expr = expr.normalize
 				return expr if expr.cache_key == to_s
 
-				raise FailureException, "#{expr} does not match #{self}"
+				raise FailureException, "#{expr} hash #{expr.cache_key}" \
+				                        " does not match #{self}"
 			end
 
 			def as_json
-				@protocol == :nocheck ? nil : [@protocol, @data]
+				Multihashes.encode(digest, Multihashes::TABLE[code])
 			end
 		end
 
-		class URI
-			include(ValueSemantics.for_attributes do
-				headers   Either(nil, Expression)
-				authority ::String
-				path      ArrayOf(::String)
-				query     Either(nil, ::String)
-			end)
+		class NoIntegrityCheck < IntegrityCheck
+			def initialize; end
 
-			def initialize(headers, authority, *path, query)
-				super(
-					headers:   headers,
-					authority: authority,
-					path:      path,
-					query:     query,
-				)
+			def to_s
+				""
 			end
 
-			def with(hash)
-				self.class.new(
-					hash.fetch(:headers, headers),
-					hash.fetch(:authority, authority),
-					*hash.fetch(:path, path),
-					hash.fetch(:query, query)
-				)
+			def hexdigest; end
+
+			def check(expr)
+				expr.normalize
 			end
 
-			def self.from_uri(uri)
-				(uri.scheme == "https" ? Https : Http).new(
-					nil,
-					"#{uri.host}:#{uri.port}",
-					*uri.path.split(/\//)[1..-1],
-					uri.query,
-					nil
-				)
+			def as_json
+				nil
+			end
+		end
+
+		Location = LazyObject.new do
+			UnionType.new(
+				alternatives: {
+					"Local"       => Builtins[:Text],
+					"Remote"      => Builtins[:Text],
+					"Environment" => Builtins[:Text],
+					"Missing"     => nil
+				}
+			)
+		end
+
+		class URI
+			include(ValueSemantics.for_attributes do
+				uri       ::URI
+				headers   Either(nil, Expression), default: nil
+			end)
+
+			def with(attrs)
+				if attrs.key?(:path)
+					attrs[:uri] =
+						uri + Util.path_components_to_uri(*attrs.delete(:path))
+				end
+
+				super
 			end
 
 			def headers
 				header_type = RecordType.new(
 					record: {
-						"header" => Builtins[:Text],
-						"value"  => Builtins[:Text]
+						"mapKey"   => Builtins[:Text],
+						"mapValue" => Builtins[:Text]
 					}
 				)
 
 				super || EmptyList.new(element_type: header_type)
 			end
 
-			def uri
-				escaped_path = path.map do |c|
-					::URI.encode_www_form_component(c).gsub("+", "%20")
-				end
-				URI("#{scheme}://#{authority}/#{escaped_path.join("/")}?#{query}")
-			end
-
 			def chain_onto(relative_to)
 				if headers.is_a?(Import)
 					with(headers: headers.with(path: headers.real_path(relative_to)))
@@ -1284,23 +1422,43 @@ module Dhall
 
 			def canonical
 				with(
-					path: (path[1..-1] + [""])
-					.reduce([[], path.first]) { |(pth, prev), c|
+					path: (path[1..-1] + [""]).reduce([[], path.first]) { |(pth, prev), c|
 						c == ".." ? [pth, prev] : [pth + [prev], c]
 					}.first.reject { |c| c == "." }
 				)
 			end
 
+			def port
+				uri.port && uri.port != uri.default_port ? uri.port : nil
+			end
+
+			def authority
+				[
+					uri.userinfo,
+					[uri.host, port].compact.join(":")
+				].compact.join("@")
+			end
+
 			def origin
-				"#{scheme}://#{authority}"
+				"#{uri.scheme}://#{authority}"
 			end
 
 			def to_s
 				uri.to_s
 			end
 
+			def location
+				Union.from(Location, "Remote", to_s.as_dhall)
+			end
+
+			def path
+				path = uri.path.split(/\//, -1)
+				path = path[1..-1] if path.length > 1 && path.first.empty?
+				path
+			end
+
 			def as_json
-				[@headers&.as_json, authority, *path, query]
+				[@headers&.as_json, authority, *path, uri.query]
 			end
 		end
 
@@ -1308,20 +1466,12 @@ module Dhall
 			def resolve(resolver)
 				resolver.resolve_http(self)
 			end
-
-			def scheme
-				"http"
-			end
 		end
 
 		class Https < URI
 			def resolve(resolver)
 				resolver.resolve_https(self)
 			end
-
-			def scheme
-				"https"
-			end
 		end
 
 		class Path
@@ -1366,6 +1516,10 @@ module Dhall
 				pathname.to_s
 			end
 
+			def location
+				Union.from(Location, "Local", to_s.as_dhall)
+			end
+
 			def as_json
 				path
 			end
@@ -1376,8 +1530,8 @@ module Dhall
 				Pathname.new("/").join(*path)
 			end
 
-			def to_uri(scheme, authority)
-				scheme.new(nil, authority, *path, nil)
+			def to_uri(scheme, base_uri)
+				scheme.new(uri: base_uri + Util.path_components_to_uri(*path))
 			end
 
 			def chain_onto(relative_to)
@@ -1394,6 +1548,10 @@ module Dhall
 				Pathname.new(".").join(*path)
 			end
 
+			def to_s
+				"./#{pathname}"
+			end
+
 			def chain_onto(relative_to)
 				relative_to.with(
 					path: relative_to.path[0..-2] + path
@@ -1473,6 +1631,10 @@ module Dhall
 				end}"
 			end
 
+			def location
+				Union.from(Location, "Environment", to_s.as_dhall)
+			end
+
 			def hash
 				@var.hash
 			end
@@ -1480,7 +1642,7 @@ module Dhall
 			def eql?(other)
 				other.is_a?(self.class) && other.var == var
 			end
-			alias eql? ==
+			alias == eql?
 
 			def as_json
 				@var
@@ -1506,6 +1668,15 @@ module Dhall
 				"missing"
 			end
 
+			def location
+				Union.from(Location, "Missing", nil)
+			end
+
+			def eql?(other)
+				other.class == self.class
+			end
+			alias == eql?
+
 			def as_json
 				[]
 			end
@@ -1525,9 +1696,16 @@ module Dhall
 			end
 		end
 
+		class AsLocation
+			def self.call(*)
+				raise "AsLocation is only a marker, you don't actually call it"
+			end
+		end
+
 		IMPORT_TYPES = [
 			Expression,
-			Text
+			Text,
+			AsLocation
 		].freeze
 
 		PATH_TYPES = [
@@ -1537,14 +1715,14 @@ module Dhall
 		].freeze
 
 		include(ValueSemantics.for_attributes do
-			integrity_check IntegrityCheck, default: IntegrityCheck.new
+			integrity_check IntegrityCheck, default: NoIntegrityCheck.new
 			import_type     Class
 			path            Either(*PATH_TYPES)
 		end)
 
 		def initialize(integrity_check, import_type, path)
 			super(
-				integrity_check: integrity_check || IntegrityCheck.new,
+				integrity_check: integrity_check || NoIntegrityCheck.new,
 				import_type:     import_type,
 				path:            path
 			)
@@ -1562,15 +1740,18 @@ module Dhall
 			path.chain_onto(relative_to).canonical
 		end
 
-		def parse_and_check(raw, deadline: Util::NoDeadline.new)
-			integrity_check.check(import_type.call(raw, deadline: deadline))
+		def parse_resolve_check(raw, deadline: Util::NoDeadline.new, **kwargs)
+			import_type.call(raw, deadline: deadline).resolve(**kwargs).then do |e|
+				integrity_check.check(TypeChecker.annotate(e))
+			end
 		end
 
 		def cache_key(relative_to)
-			if integrity_check.protocol == :nocheck
+			key = integrity_check.to_s
+			if key.empty?
 				real_path(relative_to)
 			else
-				integrity_check.to_s
+				key
 			end
 		end
 
@@ -1609,10 +1790,10 @@ module Dhall
 
 		def flatten
 			flattened = body.is_a?(LetIn) ? body.flatten : body
-			if flattened.is_a?(LetIn) || flattened.is_a?(LetBlock)
-				LetBlock.for(lets: [let] + flattened.lets, body: flattened.body)
+			if flattened.is_a?(LetBlock)
+				LetBlock.new(lets: lets + flattened.lets, body: flattened.body)
 			else
-				self
+				LetBlock.new(lets: lets, body: body)
 			end
 		end
 
@@ -1635,28 +1816,16 @@ module Dhall
 		end
 
 		def as_json
-			[25, *let.as_json, body.as_json]
+			flatten.as_json
 		end
 	end
 
-	class LetBlock < Expression
+	class LetBlock
 		include(ValueSemantics.for_attributes do
-			lets Util::ArrayOf.new(Let, min: 2)
+			lets Util::ArrayOf.new(Let)
 			body Expression
 		end)
 
-		def self.for(lets:, body:)
-			if lets.length == 1
-				LetIn.new(let: lets.first, body: body)
-			else
-				new(lets: lets, body: body)
-			end
-		end
-
-		def flatten
-			unflatten.flatten
-		end
-
 		def unflatten
 			lets.reverse.reduce(body) do |inside, let|
 				letin = LetIn.new(let: let, body: inside)
@@ -1664,10 +1833,6 @@ module Dhall
 			end
 		end
 
-		def desugar
-			unflatten(&:desugar)
-		end
-
 		def as_json
 			[25, *lets.flat_map(&:as_json), body.as_json]
 		end
@@ -1683,4 +1848,14 @@ module Dhall
 			[26, value.as_json, type.as_json]
 		end
 	end
+
+	class Assertion < Expression
+		include(ValueSemantics.for_attributes do
+			type Expression
+		end)
+
+		def as_json
+			[19, type.as_json]
+		end
+	end
 end