dhall 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aaa68fc11b3223d666fd199cf507d4ca5744e31d
-  data.tar.gz: 0b3643c8d75220906f9ac34b08e47c613bb1efb5
+  metadata.gz: 2189303de0238086f008d9fa07f0a24de1f0d825
+  data.tar.gz: 33dd23d2bcffb5e1171a7a0a08320c02be502fe1
 SHA512:
-  metadata.gz: c5225d59efa8144191b163ec0cc565ec78846d7107f479e4dccc78056ff38a744865e86c857cfedf0808f836c292044bed91aaa8c4b74b844b9f380fc14da366
-  data.tar.gz: 675ae2377aabb52b68a6f5db83eb8ebab10b9a44f13d5025908b1d6adc2f8a20b25ea4e74e7b48adaf41ae982e23bc5f3e515c8572667717fa7ed21bf4666569
+  metadata.gz: 3e3385fa51023333875319b5355a8eb11dcb9e69b0bbaa6b2bbf368003ea46a79daf7819dfcc9e8e444f028e6edbbf33dba8a3e68043a2a92a97767f82819bca
+  data.tar.gz: d690a7f50b99ee3d8f7a16ab4e7439c42b1500cc23186e30a6db73c8c76af3ca452c9febc303f7ce179166cc55629188720a1ea9839469c3c29356559a25d2d6

data/README.md

@@ -6,7 +6,7 @@ This is a Ruby implementation of the Dhall configuration language.  Dhall is a p
 
 This project follows semantic versioning, and every tagged version claims to adhere to the version of the dhall-lang standard that is linked in the dhall-lang submodule.
 
-For the purposes of considering what is a "breaking change" only the API as documented in this documentation is considered, regardless of any other exposed parts of the library.  Anything not documented here may change at any time, but backward-incompatible changes to anything documented here will be accompanied by a major-version increment.
+For the purposes of considering what is a "breaking change" only the API as documented in this README is considered, regardless of any other exposed parts of the library.  Anything not documented here may change at any time, but backward-incompatible changes to anything documented here will be accompanied by a major-version increment.
 
 ## Installation
 
@@ -45,7 +45,15 @@ Wherever possible, you should use the `Promise` API and treat `Dhall.load` as an
 
     Dhall.load("1 + 1").sync # => #<Dhall::Natural value=2>
 
-**This will block the thread it is run from until the whole load operation is complete.  Never call #sync from an async context.**
+**This will block the thread it is run from until the whole load operation is complete.  Never call `#sync` from an async context.**
+
+### Timeout
+
+It is possible for malicious entities to craft Dhall expressions which take an unreasonable amount of time to load.  To protect against this, `Dhall.load` implements a timeout mechanism with a default of 10 seconds.  You may specify an alternate timeout like so:
+
+	Dhall.load("1 + 1", timeout: 1)               # 1 second timeout
+	Dhall.load("1 + 1", timeout: 0.1)             # 0.1 second timeut
+	Dhall.load("1 + 1", timeout: Float::INFINITY) # Never timeout
 
 ### Customizing Import Resolution
 
@@ -174,7 +182,7 @@ A Dhall expression may be a list of other expressions.  Lists are `Enumerable` a
       list[100]                          # => #<Dhall::OptionalNone value_type=...>
       list.reverse                       # => #<Dhall::List elements=[#<Dhall::Natural value=2>, #<Dhall::Natural value=1>] element_type=...>
       list.join(",")                     # => "1,2"
-      list.to_a                          # => [1,2]
+      list.to_a                          # => [#<Dhall::Natural value=1>, #<Dhall::Natural value=2>]
     end
 
 ## Record
@@ -241,6 +249,25 @@ You may wish to convert your existing Ruby objects to Dhall expressions.  This c
 
 Many methods on Dhall expressions call `#as_dhall` on their arguments, so you can define it on your own objects to produce a custom serialization.
 
+If your object is already set up to customise its YAML serialization using `#encode_with`, the default `#as_dhall` implementation will use that.
+
+When you want a full replacement for `YAML.safe_load` you can use the `Dhall::Coder` API:
+
+    Dhall::Coder.dump(1)               # => "\x82\x0F\x01"
+    Dhall::Coder.load("\x82\x0F\x01")  # => 1
+    Dhall::Coder.dump(Object.new)      # => ArgumentError
+
+    coder = Dhall::Coder.new(safe: Object)
+    coder.load_async(coder.dump(Object.new)).then do |value|
+      value # => #<Object:0x...>
+    end
+
+**Warning: calling `Dhall::Coder.load` or `Dhall::Coder#load` on an expression with imports will perform synchronous IO. See the warnings for the `#sync` method above.**
+
+Both `Dhall::Coder` and all instances of `Dhall::Coder` are compatible to drop-in for `ActiveRecord::Base#serialize` like so in your models:
+
+    serialize :column, Dhall::Coder
+
 ## Porting from YAML or JSON Configuration
 
 To aid in converting your existing configurations or serialized data, there are included some experimental scripts:

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).as_dhall))
+STDOUT.write(CBOR.encode(YAML.safe_load(STDIN.read, [Symbol]).as_dhall))

data/dhall.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
 	spec.name          = "dhall"
-	spec.version       = "0.1.0"
+	spec.version       = `git describe --always --dirty`
 	spec.authors       = ["Stephen Paul Weber"]
 	spec.email         = ["dev@singpolyma.net"]
 	spec.license       = "GPL-3.0"

data/lib/dhall.rb

@@ -4,6 +4,7 @@ require "dhall/as_dhall"
 require "dhall/ast"
 require "dhall/binary"
 require "dhall/builtins"
+require "dhall/coder"
 require "dhall/normalize"
 require "dhall/parser"
 require "dhall/resolve"
@@ -12,26 +13,38 @@ require "dhall/typecheck"
 module Dhall
 	using Dhall::AsDhall
 
-	def self.load(source, resolver: Resolvers::Default.new)
+	def self.load(
+		source,
+		resolver: Resolvers::Default.new,
+		timeout: 10
+	)
+		deadline = Util::Deadline.for_timeout(timeout)
 		Promise.resolve(nil).then {
-			load_raw(source).resolve(resolver: resolver)
+			load_raw(source.to_s, timeout: timeout).resolve(
+				resolver: resolver.with_deadline(deadline)
+			)
 		}.then do |resolved|
-			TypeChecker.for(resolved).annotate(TypeChecker::Context.new).normalize
+			deadline.timeout_block do
+				TypeChecker.for(resolved).annotate(TypeChecker::Context.new).normalize
+			end
 		end
 	end
 
-	def self.load_raw(source)
-		begin
-			return from_binary(source) if source.encoding == Encoding::BINARY
-		rescue Exception # rubocop:disable Lint/RescueException
-			# Parsing CBOR failed, so guess this is source text in standard UTF-8
-			return load_raw(source.force_encoding("UTF-8"))
-		end
+	def self.load_raw(source, timeout: 10)
+		source = Util.text_or_binary(source)
 
-		Parser.parse(source.encode("UTF-8")).value
+		Util::Deadline.for_timeout(timeout).timeout_block do
+			if source.encoding == Encoding::BINARY
+				from_binary(source)
+			else
+				Parser.parse(source).value
+			end
+		end
 	end
 
 	def self.dump(o)
 		CBOR.encode(o.as_dhall)
 	end
+
+	class TimeoutException < StandardError; end
 end

data/lib/dhall/as_dhall.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "ostruct"
+require "psych"
 
 module Dhall
 	module AsDhall
@@ -35,7 +36,21 @@ module Dhall
 
 		refine ::String do
 			def as_dhall
-				Text.new(value: self)
+				if encoding == Encoding::BINARY
+					bytes.as_dhall
+				else
+					Text.new(value: self)
+				end
+			end
+		end
+
+		refine ::Symbol do
+			def as_dhall
+				Dhall::Union.new(
+					tag:          to_s,
+					value:        nil,
+					alternatives: Dhall::UnionType.new(alternatives: {})
+				)
 			end
 		end
 
@@ -165,29 +180,38 @@ module Dhall
 
 		refine ::OpenStruct do
 			def as_dhall
-				annotation = TypeChecker
-					            .for(to_h.as_dhall)
-					            .annotate(TypeChecker::Context.new)
-				Union.new(
-					tag:          "OpenStruct",
-					value:        annotation,
-					alternatives: UnionType.new(alternatives: {})
+				expr = to_h.as_dhall
+				type = TypeChecker.for(expr).annotate(TypeChecker::Context.new).type
+				Union.from(
+					UnionType.new(alternatives: { "OpenStruct" => type }),
+					"OpenStruct",
+					expr
 				)
 			end
 		end
 
-		refine ::Object do
+		refine ::Psych::Coder do
 			def as_dhall
-				ivars = instance_variables.each_with_object({}) { |ivar, h|
-					h[ivar.to_s[1..-1]] = instance_variable_get(ivar)
-				}.as_dhall
+				case type
+				when :seq
+					seq
+				when :map
+					map
+				else
+					scalar
+				end.as_dhall
+			end
+		end
 
-				type = TypeChecker.for(ivars).annotate(TypeChecker::Context.new).type
+		refine ::Object do
+			def as_dhall
 				tag = self.class.name
+				expr = Util.psych_coder_from(tag, self).as_dhall
+				type = TypeChecker.for(expr).annotate(TypeChecker::Context.new).type
 				Union.from(
 					UnionType.new(alternatives: { tag => type }),
 					tag,
-					ivars
+					expr
 				)
 			end
 		end

data/lib/dhall/ast.rb

@@ -41,10 +41,6 @@ module Dhall
 			end
 		end
 
-		def <<(other)
-			Operator::TextConcatenate.new(lhs: self, rhs: other)
-		end
-
 		def concat(other)
 			Operator::ListConcatenate.new(lhs: self, rhs: other)
 		end
@@ -118,9 +114,7 @@ module Dhall
 		end)
 
 		def self.for(function:, argument:)
-			if function == Variable["Some"]
-				Optional.new(value: argument)
-			elsif function == Variable["None"]
+			if function == Builtins[:None]
 				OptionalNone.new(value_type: argument)
 			else
 				new(function: function, argument: argument)
@@ -148,7 +142,7 @@ module Dhall
 
 	class Function < Expression
 		include(ValueSemantics.for_attributes do
-			var  Util::AllOf.new(::String, Util::Not.new(Util::BuiltinName))
+			var  ::String
 			type Either(nil, Expression) # nil is not allowed in proper Dhall
 			body Expression
 		end)
@@ -234,6 +228,10 @@ module Dhall
 		def as_json
 			value
 		end
+
+		def self.as_dhall
+			Builtins[:Bool]
+		end
 	end
 
 	class Variable < Expression
@@ -253,8 +251,6 @@ module Dhall
 		def as_json
 			if name == "_"
 				index
-			elsif index.zero?
-				name
 			else
 				[name, index]
 			end
@@ -309,9 +305,13 @@ module Dhall
 			end
 		end
 
+		def self.as_dhall
+			Builtins[:List]
+		end
+
 		def type
 			Dhall::Application.new(
-				function: Dhall::Variable["List"],
+				function: self.class.as_dhall,
 				argument: element_type
 			)
 		end
@@ -321,7 +321,10 @@ module Dhall
 		end
 
 		def map(type: nil, &block)
-			with(elements: elements.each_with_index.map(&block), element_type: type)
+			with(
+				elements:     elements.each_with_index.map(&block),
+				element_type: type&.as_dhall
+			)
 		end
 
 		def each(&block)
@@ -426,6 +429,10 @@ module Dhall
 			end
 		end
 
+		def self.as_dhall
+			Builtins[:Natural]
+		end
+
 		def initialize(normalized: false, **attrs)
 			@normalized = normalized
 			super(**attrs)
@@ -435,7 +442,7 @@ module Dhall
 			return unless value_type
 
 			Dhall::Application.new(
-				function: Dhall::Variable["Optional"],
+				function: Builtins[:Optional],
 				argument: value_type
 			)
 		end
@@ -462,6 +469,10 @@ module Dhall
 			value_type Expression
 		end)
 
+		def self.as_dhall
+			Builtins[:None]
+		end
+
 		def map(type: nil)
 			type.nil? ? self : with(value_type: type)
 		end
@@ -475,7 +486,10 @@ module Dhall
 		end
 
 		def as_json
-			[0, Variable["None"].as_json, value_type.as_json]
+			Application.new(
+				function: self.class.as_dhall,
+				argument: value_type
+			).as_json
 		end
 	end
 
@@ -780,10 +794,9 @@ module Dhall
 		end
 
 		def get_constructor(selector)
-			var = Util::BuiltinName === selector ? "_" : selector
 			type = alternatives.fetch(selector)
-			body = Union.from(self, selector, Variable[var])
-			Function.new(var: var, type: type, body: body)
+			body = Union.from(self, selector, Variable[selector])
+			Function.new(var: selector, type: type, body: body)
 		end
 
 		def constructor_types
@@ -791,8 +804,7 @@ module Dhall
 				ctypes[k] = if type.nil?
 					self
 				else
-					var = Util::BuiltinName === k ? "_" : k
-					Forall.new(var: var, type: type, body: self)
+					Forall.new(var: k, type: type, body: self)
 				end
 			end
 		end
@@ -893,6 +905,10 @@ module Dhall
 			value (0..Float::INFINITY)
 		end)
 
+		def self.as_dhall
+			Builtins[:Natural]
+		end
+
 		def coerce(other)
 			[other.as_dhall, self]
 		end
@@ -954,6 +970,10 @@ module Dhall
 			value ::Integer
 		end)
 
+		def self.as_dhall
+			Builtins[:Integer]
+		end
+
 		def to_s
 			"#{value >= 0 ? "+" : ""}#{value}"
 		end
@@ -976,6 +996,10 @@ module Dhall
 			value ::Float
 		end)
 
+		def self.as_dhall
+			Builtins[:Double]
+		end
+
 		def to_s
 			value.to_s
 		end
@@ -1030,6 +1054,10 @@ module Dhall
 			value ::String, coerce: ->(s) { s.encode("UTF-8") }
 		end)
 
+		def self.as_dhall
+			Builtins[:Text]
+		end
+
 		def <<(other)
 			if other.is_a?(Text)
 				with(value: value + other.value)
@@ -1115,13 +1143,6 @@ module Dhall
 				query     Either(nil, ::String)
 			end)
 
-			HeaderType = RecordType.new(
-				record: {
-					"header" => Variable["Text"],
-					"value"  => Variable["Text"]
-				}
-			)
-
 			def initialize(headers, authority, *path, query)
 				super(
 					headers:   headers,
@@ -1151,7 +1172,14 @@ module Dhall
 			end
 
 			def headers
-				super || EmptyList.new(element_type: HeaderType)
+				header_type = RecordType.new(
+					record: {
+						"header" => Builtins[:Text],
+						"value"  => Builtins[:Text]
+					}
+				)
+
+				super || EmptyList.new(element_type: header_type)
 			end
 
 			def uri
@@ -1225,13 +1253,15 @@ module Dhall
 			end
 
 			def self.from_string(s)
-				parts = s.to_s.split(/\//)
-				if parts.first == ""
-					AbsolutePath.new(*parts[1..-1])
-				elsif parts.first == "~"
-					RelativeToHomePath.new(*parts[1..-1])
+				prefix, *suffix = s.to_s.split(/\//)
+				if prefix == ""
+					AbsolutePath.new(*suffix)
+				elsif prefix == "~"
+					RelativeToHomePath.new(*suffix)
+				elsif prefix == ".."
+					RelativeToParentPath.new(*suffix)
 				else
-					RelativePath.new(*parts)
+					RelativePath.new(prefix, *suffix)
 				end
 			end
 
@@ -1303,7 +1333,7 @@ module Dhall
 				Pathname.new("~").join(*@path)
 			end
 
-			def chain_onto(*)
+			def chain_onto(relative_to)
 				if relative_to.is_a?(URI)
 					raise ImportBannedException, "remote import cannot import #{self}"
 				end
@@ -1331,6 +1361,8 @@ module Dhall
 				end
 			end
 
+			attr_reader :var
+
 			def initialize(var)
 				@var = var
 			end
@@ -1340,28 +1372,27 @@ module Dhall
 					raise ImportBannedException, "remote import cannot import #{self}"
 				end
 
-				real_path.chain_onto(relative_to)
+				self
+			end
+
+			def path
+				[]
+			end
+
+			def with(path:)
+				Path.from_string(path.join("/"))
 			end
 
 			def canonical
-				real_path.canonical
+				self
 			end
 
 			def real_path
-				val = ENV.fetch(@var) do
-					raise ImportFailedException, "No #{self}"
-				end
-				if val =~ /\Ahttps?:\/\//
-					URI.from_uri(URI(val))
-				else
-					Path.from_string(val)
-				end
+				self
 			end
 
 			def resolve(resolver)
-				Promise.resolve(nil).then do
-					real_path.resolve(resolver)
-				end
+				resolver.resolve_environment(self)
 			end
 
 			def origin
@@ -1372,6 +1403,15 @@ module Dhall
 				"env:#{as_json}"
 			end
 
+			def hash
+				@var.hash
+			end
+
+			def eql?(other)
+				other.is_a?(self.class) && other.var == var
+			end
+			alias eql? ==
+
 			def as_json
 				@var.gsub(/[\"\\\a\b\f\n\r\t\v]/) do |c|
 					"\\" + ESCAPES.find { |(_, v)| v == c }.first
@@ -1404,13 +1444,15 @@ module Dhall
 		end
 
 		class Expression
-			def self.call(import_value)
-				Dhall.load_raw(import_value)
+			def self.call(import_value, deadline: Util::NoDeadline.new)
+				return import_value if import_value.is_a?(Dhall::Expression)
+
+				Dhall.load_raw(import_value, timeout: deadline.timeout)
 			end
 		end
 
 		class Text
-			def self.call(import_value)
+			def self.call(import_value, deadline: Util::NoDeadline.new)
 				Dhall::Text.new(value: import_value)
 			end
 		end
@@ -1452,13 +1494,13 @@ module Dhall
 			path.chain_onto(relative_to).canonical
 		end
 
-		def parse_and_check(raw)
-			integrity_check.check(import_type.call(raw))
+		def parse_and_check(raw, deadline: Util::NoDeadline.new)
+			integrity_check.check(import_type.call(raw, deadline: deadline))
 		end
 
 		def cache_key(relative_to)
 			if integrity_check.protocol == :nocheck
-				real_path(relative_to).to_s
+				real_path(relative_to)
 			else
 				integrity_check.to_s
 			end
@@ -1477,7 +1519,7 @@ module Dhall
 
 	class Let < Expression
 		include(ValueSemantics.for_attributes do
-			var    Util::AllOf.new(::String, Util::Not.new(Util::BuiltinName))
+			var    ::String
 			assign Expression
 			type   Either(nil, Expression)
 		end)