dhall 0.1.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: aaa68fc11b3223d666fd199cf507d4ca5744e31d
-  data.tar.gz: 0b3643c8d75220906f9ac34b08e47c613bb1efb5
+SHA256:
+  metadata.gz: 5b0efbcf23922a25863898fa6ac51fc625f5ecd1590f7b95858ea736de8e091b
+  data.tar.gz: 96685b1fca760158f9a84ca6c7b8a8fdc1d0203c1f25af94d989c492af82e533
 SHA512:
-  metadata.gz: c5225d59efa8144191b163ec0cc565ec78846d7107f479e4dccc78056ff38a744865e86c857cfedf0808f836c292044bed91aaa8c4b74b844b9f380fc14da366
-  data.tar.gz: 675ae2377aabb52b68a6f5db83eb8ebab10b9a44f13d5025908b1d6adc2f8a20b25ea4e74e7b48adaf41ae982e23bc5f3e515c8572667717fa7ed21bf4666569
+  metadata.gz: 1785d0b615378c128b3729b6d4d11df4f4c8da9beb07435b265cf1ff8f38583e4abb1ee5877029c474451acd465df1361175fdb8fab0d32358740765f339072e
+  data.tar.gz: 1ab4e4a5bc480ca0774429ce56d6007c5efc8e3009e8219c91c71b18821e2453573d23d1ece119ebf9c36e369cacf0ffeb1d681e869044e98200354feed04d63

data/README.md

@@ -6,13 +6,13 @@ 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
 
 Add this line to your application's Gemfile:
 
-    gem 'dhall'
+    gem "dhall"
 
 And then execute:
 
@@ -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/dhall-compile

@@ -0,0 +1,111 @@
+#!/usr/bin/ruby
+# frozen_string_literal: true
+
+require "dhall"
+require "optparse"
+
+@extension = ".dhallb"
+
+def compile(source)
+	Dhall.load(
+		source,
+		timeout:  Float::INFINITY,
+		resolver: Dhall::Resolvers::Default.new(
+			max_depth: Float::INFINITY
+		)
+	)
+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)
+	end
+	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]"
+
+	opts.on(
+		"-oDIRECTORY",
+		"--output-directory DIRECTORY",
+		"Write output to this directory"
+	) do |dir|
+		@output_directory = Pathname.new(dir)
+	end
+
+	opts.on(
+		"-e [EXTENSION]",
+		"--extension [EXTENSION]",
+		"Use this extension for files (default .dhallb)"
+	) do |ext|
+		@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!
+
+if ARGV.empty?
+	warn opt_parser
+	exit 0
+end
+
+ARGV.map(&Pathname.method(:new)).each do |path|
+	if !path.exist? && path.to_s == "-"
+		warn "Compiling STDIN to STDOUT"
+		compile(STDIN.read).then(&STDOUT.method(:write)).sync
+	elsif path.file?
+		compile_file(path, relative_to: path.dirname).sync
+	elsif path.directory?
+		warn "Recursively compiling #{path}"
+		path.find.flat_map do |child|
+			next if !child.file? || child.extname == ".dhallb"
+			compile_file(child, relative_to: path).sync
+		end
+	else
+		warn "#{path} may not exist"
+		exit 1
+	end
+end

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

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"
@@ -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.1.3"
 	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.rb

@@ -4,34 +4,48 @@ 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"
 require "dhall/typecheck"
+require "dhall/types"
 
 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,41 +1,108 @@
 # frozen_string_literal: true
 
 require "ostruct"
+require "psych"
 
 module Dhall
 	module AsDhall
 		TAGS = {
-			::Integer    => "Integer",
+			::Array      => "List",
 			::FalseClass => "Bool",
-			::Integer    => "Integer",
 			::Float      => "Double",
+			::Hash       => "Record",
+			::Integer    => "Integer",
+			::Integer    => "Integer",
 			::NilClass   => "None",
 			::String     => "Text",
 			::TrueClass  => "Bool"
 		}.freeze
 
-		def self.tag_for(o, type)
+		def self.tag_for(o)
 			return "Natural" if o.is_a?(::Integer) && !o.negative?
 
 			TAGS.fetch(o.class) do
-				"#{o.class.name}_#{type.digest.hexdigest}"
+				o.class.name
+			end
+		end
+
+		class AnnotatedExpressionList
+			attr_reader :type
+			attr_reader :exprs
+
+			def self.from(type_annotation)
+				if type_annotation.nil?
+					new(nil, [nil])
+				else
+					new(type_annotation.type, [type_annotation.value])
+				end
+			end
+
+			def initialize(type, exprs)
+				@type = type
+				@exprs = exprs
+			end
+
+			def +(other)
+				raise "#{type} != #{other.type}" if type != other.type
+				self.class.new(type, exprs + other.exprs)
 			end
 		end
 
-		def self.union_of(values_and_types)
-			z = [UnionType.new(alternatives: {}), []]
-			values_and_types.reduce(z) do |(ut, tags), (v, t)|
-				tag = tag_for(v, t)
-				[
-					ut.merge(UnionType.new(alternatives: { tag => t })),
-					tags + [tag]
-				]
+		class UnionInferer
+			def initialize(tagged={})
+				@tagged = tagged
+			end
+
+			def union_type
+				UnionType.new(alternatives: Hash[@tagged.map { |k, v| [k, v.type] }])
+			end
+
+			def union_for(expr)
+				if expr.is_a?(Enum)
+					tag = expr.tag
+					expr = nil
+				else
+					tag = @tagged.keys.find { |k| @tagged[k].exprs.include?(expr) }
+				end
+				expr = expr.extract if expr.is_a?(Union)
+				Union.from(union_type, tag, expr)
+			end
+
+			def with(tag, type_annotation)
+				anno = AnnotatedExpressionList.from(type_annotation)
+				if @tagged.key?(tag) && @tagged[tag].type != anno.type
+					disambiguate_against(tag, anno)
+				else
+					self.class.new(@tagged.merge(tag => anno) { |_, x, y| x + y })
+				end
+			end
+
+			def disambiguate_against(tag, anno)
+				self.class.new(
+					@tagged.reject { |k, _| k == tag }.merge(
+						"#{tag}_#{@tagged[tag].type.digest.hexdigest}" => @tagged[tag],
+						"#{tag}_#{anno.type.digest.hexdigest}"         => anno
+					)
+				)
 			end
 		end
 
 		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::Enum.new(
+					tag:          to_s,
+					alternatives: Dhall::UnionType.new(alternatives: {})
+				)
 			end
 		end
 
@@ -128,17 +195,28 @@ module Dhall
 
 			class Union
 				def initialize(values, exprs, types)
-					@values = values
+					@tags, @types = values.zip(types).map { |(value, type)|
+						if type.is_a?(UnionType) && type.alternatives.length == 1
+							type.alternatives.to_a.first
+						else
+							[AsDhall.tag_for(value), type]
+						end
+					}.transpose
 					@exprs = exprs
-					@types = types
+					@inferer = UnionInferer.new
 				end
 
 				def list
-					ut, tags = AsDhall.union_of(@values.zip(@types))
-
-					List.new(elements: @exprs.zip(tags).map do |(expr, tag)|
-						Dhall::Union.from(ut, tag, expr)
-					end)
+					final_inferer =
+						@tags
+						.zip(@exprs, @types)
+						.reduce(@inferer) do |inferer, (tag, expr, type)|
+							inferer.with(
+								tag,
+								type.nil? ? nil : TypeAnnotation.new(value: expr, type: type)
+							)
+						end
+					List.new(elements: @exprs.map(&final_inferer.method(:union_for)))
 				end
 			end
 		end
@@ -165,31 +243,52 @@ 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
+
+		refine ::Proc do
+			def as_dhall
+				FunctionProxy.new(self)
+			end
+		end
+
+		refine ::Method do
+			def as_dhall
+				to_proc.as_dhall
+			end
+		end
 	end
 end