dhall 0.3.0 → 0.4.0

data/lib/dhall/resolve.rb

@@ -38,16 +38,10 @@ module Dhall
 				req["Origin"] = parent_origin
 				req["Access-Control-Request-Method"] = "GET"
 				req["Access-Control-Request-Headers"] =
-					source.headers.map { |h| h.fetch("header").to_s }.join(",")
-				r = Net::HTTP.start(
-					uri.hostname,
-					uri.port,
-					use_ssl:       uri.scheme == "https",
-					open_timeout:  timeout,
-					ssl_timeout:   timeout,
-					read_timeout:  timeout,
-					write_timeout: timeout
-				) { |http| http.request(req) }
+					source.headers.to_a.map { |h|
+						(h.fetch("header") { h.fetch("mapKey") }).to_s
+					}.join(",")
+				r = Util.net_http_req_with_timeout(uri, req, timeout: timeout)
 
 				raise ImportFailedException, source if r.code != "200"
 				unless r["Access-Control-Allow-Origin"] == parent_origin ||
@@ -63,19 +57,17 @@ module Dhall
 					PreflightCORS.call(source, parent_origin)
 					timeout = source.deadline.timeout
 					uri = source.uri
-					req = Net::HTTP::Get.new(uri)
-					source.headers.each do |header|
-						req[header.fetch("header").to_s] = header.fetch("value").to_s
+					r = loop do
+						req = Net::HTTP::Get.new(uri)
+						source.headers.each do |header|
+							req[(header.fetch("header") { header.fetch("mapKey") }).to_s] =
+								(header.fetch("value") { header.fetch("mapValue") }).to_s
+						end
+						r = Util.net_http_req_with_timeout(uri, req, timeout: timeout)
+
+						break r unless ["301", "302", "303", "307", "308"].include?(r.code)
+						uri = URI(r["Location"])
 					end
-					r = Net::HTTP.start(
-						uri.hostname,
-						uri.port,
-						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"
 					r.body
@@ -86,7 +78,7 @@ module Dhall
 		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")
+					s = s.dup.force_encoding("UTF-8")
 					unless s.valid_encoding?
 						raise ImportFailedException, "#{s.inspect} is not valid UTF-8"
 					end
@@ -106,7 +98,7 @@ module Dhall
 				path_reader: ReadPathSources,
 				http_reader: ReadHttpSources,
 				https_reader: http_reader,
-				public_gateway: "cloudflare-ipfs.com"
+				public_gateway: URI("https://cloudflare-ipfs.com")
 			)
 				@path_reader = path_reader
 				@http_reader = http_reader
@@ -139,7 +131,7 @@ module Dhall
 			def gateway_fallback(source, promise)
 				promise.catch {
 					@http_reader.call([
-						source.to_uri(Import::Http, "localhost:8000")
+						source.to_uri(Import::Http, URI("http://localhost:8000"))
 					], "localhost").first
 				}.catch do
 					@https_reader.call([
@@ -182,11 +174,11 @@ module Dhall
 
 			def fetch(key, &block)
 				if key.is_a?(String) && key.start_with?("sha256:")
-					file = @dir + key.sub(/^sha256:/, "")
+					file = @dir + key.sub(/^sha256:/, "1220")
 					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) }
+						file.open("wb") { |fh| fh.write(result.to_cbor) }
 						result
 					end
 				else
@@ -359,7 +351,7 @@ module Dhall
 				http_reader: ReadHttpSources,
 				https_reader: http_reader,
 				environment_reader: ReadEnvironmentSources,
-				ipfs_public_gateway: "cloudflare-ipfs.com",
+				ipfs_public_gateway: URI("https://cloudflare-ipfs.com"),
 				cache: RamCache.new,
 				max_depth: 50
 			)
@@ -427,9 +419,25 @@ module Dhall
 			).then { |h| @expr.with(h) }
 		end
 
+		class ImportAsLocationResolver < ExpressionResolver
+			def resolve(resolver:, relative_to:)
+				Promise.resolve(nil).then do
+					@expr.real_path(relative_to).location
+				end
+			end
+		end
+
 		class ImportResolver < ExpressionResolver
 			register_for Import
 
+			def self.new(expr)
+				if expr.import_type == Import::AsLocation
+					ImportAsLocationResolver.new(expr)
+				else
+					super
+				end
+			end
+
 			def resolve(resolver:, relative_to:)
 				Promise.resolve(nil).then do
 					resolver.cache_fetch(@expr.cache_key(relative_to)) do

data/lib/dhall/typecheck.rb

@@ -12,7 +12,7 @@ module Dhall
 
 		def self.assert_type(expr, assertion, message, context:)
 			aexpr = self.for(expr).annotate(context)
-			type = aexpr.type
+			type = aexpr.type.normalize
 			raise TypeError, "#{message}: #{type}" unless assertion === type
 			aexpr
 		end
@@ -40,9 +40,13 @@ module Dhall
 			@typecheckers[node_type] ||= [typechecker, extras]
 		end
 
-		def self.type_of(expr)
+		def self.annotate(expr)
 			return if expr.nil?
-			TypeChecker.for(expr).annotate(TypeChecker::Context.new).type
+			TypeChecker.for(expr).annotate(TypeChecker::Context.new)
+		end
+
+		def self.type_of(expr)
+			annotate(expr)&.type
 		end
 
 		class Context
@@ -358,10 +362,16 @@ module Dhall
 			TypeChecker.register self, Dhall::EmptyList
 
 			def initialize(expr)
-				@expr = expr
+				@expr = expr.with(type: expr.type.normalize)
 			end
 
 			def annotate(context)
+				TypeChecker.assert @expr.type, Dhall::Application,
+				                   "EmptyList unknown type #{@expr.type.inspect}"
+
+				TypeChecker.assert @expr.type.function, Builtins[:List],
+				                   "EmptyList unknown type #{@expr.type.inspect}"
+
 				TypeChecker.assert_type @expr.element_type, Builtins[:Type],
 				                        "EmptyList element type not of type Type",
 				                        context: context
@@ -383,7 +393,7 @@ module Dhall
 				end
 
 				def annotation
-					list = @alist.with(element_type: element_type)
+					list = @alist.with(type: Builtins[:List].call(element_type))
 					Dhall::TypeAnnotation.new(type: list.type, value: list)
 				end
 
@@ -537,12 +547,13 @@ module Dhall
 
 			class Selector
 				def self.for(annotated_record)
-					if annotated_record.type == Builtins[:Type]
+					typ = annotated_record.type.normalize
+					if KINDS.include?(typ)
 						TypeSelector.new(annotated_record.value)
-					elsif annotated_record.type.class == Dhall::RecordType
-						new(annotated_record.type)
+					elsif typ.class == Dhall::RecordType
+						new(typ)
 					else
-						raise TypeError, "RecordSelection on #{annotated_record.type}"
+						raise TypeError, "RecordSelection on #{typ}"
 					end
 				end
 
@@ -604,6 +615,33 @@ module Dhall
 			end
 		end
 
+		class RecordProjectionByExpression
+			TypeChecker.register self, Dhall::RecordProjectionByExpression
+
+			def initialize(projection)
+				@selector = projection.selector.normalize
+				@project_by_expression = projection
+				@project_by_keys = Dhall::RecordProjection.for(
+					@project_by_expression.record,
+					@selector.keys
+				)
+			end
+
+			def annotate(context)
+				TypeChecker.assert @selector, Dhall::RecordType,
+				                   "RecordProjectionByExpression on #{@selector.class}"
+
+				TypeChecker.assert_type @project_by_keys, @selector,
+				                        "Type doesn't match #{@selector}",
+				                        context: context
+
+				Dhall::TypeAnnotation.new(
+					value: @project_by_expression,
+					type:  @selector
+				)
+			end
+		end
+
 		class Enum
 			TypeChecker.register self, Dhall::Enum
 
@@ -648,6 +686,39 @@ module Dhall
 			end
 		end
 
+		class ToMap
+			TypeChecker.register self, Dhall::ToMap
+
+			def initialize(tomap)
+				@tomap = tomap
+				@record = TypeChecker.for(tomap.record)
+			end
+
+			def check_annotation(record_type)
+				if record_type.is_a?(Dhall::EmptyRecordType)
+					TypeChecker.assert @tomap.type, Dhall::Expression,
+					                   "toMap {=} has no annotation"
+				else
+					t = Types::MAP(v: record_type.record.values.first)
+
+					TypeChecker.assert t, (@tomap.type || t),
+					                   "toMap does not match annotation"
+				end
+			end
+
+			def annotate(context)
+				record_type = @record.annotate(context).type
+				TypeChecker.assert record_type, Dhall::RecordType,
+				                   "toMap on a non-record: #{record_type.inspect}"
+
+				TypeChecker.assert record_type.record.values, Util::ArrayAllTheSame,
+				                   "toMap heterogenous: #{record_type.inspect}"
+
+				type = check_annotation(record_type)
+				Dhall::TypeAnnotation.new(value: @tomap, type: type)
+			end
+		end
+
 		class Merge
 			TypeChecker.register self, Dhall::Merge
 
@@ -1209,12 +1280,13 @@ module Dhall
 			TypeChecker.register self, Dhall::Builtin
 
 			def self.for(builtin)
-				unfilled = builtin.unfill
-				if unfilled != builtin
-					TypeChecker.for(unfilled)
-				else
-					new(builtin)
+				if builtin.is_a?(Dhall::BuiltinFunction)
+					if (unfilled = builtin.unfill) != builtin
+						return TypeChecker.for(unfilled)
+					end
 				end
+
+				new(builtin)
 			end
 
 			def initialize(builtin)

data/lib/dhall/types.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "dhall/builtins"
+
+module Dhall
+	module Types
+		def self.MAP_ENTRY(k: Builtins[:Text], v: Builtins[:Text])
+			RecordType.new(
+				record: {
+					"mapKey" => k, "mapValue" => v
+				}
+			)
+		end
+
+		def self.MAP(k: Builtins[:Text], v: Builtins[:Text])
+			Builtins[:List].call(MAP_ENTRY(k: k, v: v))
+		end
+	end
+end

data/lib/dhall/util.rb

@@ -181,5 +181,36 @@ module Dhall
 		def self.longest_common_prefix(a, b)
 			a.zip(b).take_while { |(x, y)| x == y }.map(&:first)
 		end
+
+		def self.indent_size(str)
+			if str.end_with?("\n")
+				0
+			else
+				str
+					.scan(/^[ \t]*(?=[^ \t\n]|\Z)/)
+					.map(&:chars)
+					.reduce(&method(:longest_common_prefix))&.length.to_i
+			end
+		end
+
+		def self.path_components_to_uri(*components)
+			URI("/#{components.map(&method(:uri_escape)).join("/")}")
+		end
+
+		def self.uri_escape(s)
+			::URI.encode_www_form_component(s).gsub("+", "%20")
+		end
+
+		def self.net_http_req_with_timeout(uri, req, timeout:)
+			Net::HTTP.start(
+				uri.hostname,
+				uri.port,
+				use_ssl:       uri.scheme == "https",
+				open_timeout:  timeout,
+				ssl_timeout:   timeout,
+				read_timeout:  timeout,
+				write_timeout: timeout
+			) { |http| http.request(req) }
+		end
 	end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: dhall
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Stephen Paul Weber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-13 00:00:00.000000000 Z
+date: 2019-07-27 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base32
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
 - !ruby/object:Gem::Dependency
   name: cbor
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: lazy_object
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+- !ruby/object:Gem::Dependency
+  name: multihashes
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.3
 - !ruby/object:Gem::Dependency
   name: promise.rb
   requirement: !ruby/object:Gem::Requirement
@@ -137,6 +179,7 @@ files:
 - lib/dhall/parser.rb
 - lib/dhall/resolve.rb
 - lib/dhall/typecheck.rb
+- lib/dhall/types.rb
 - lib/dhall/util.rb
 - lib/dhall/visitor.rb
 homepage: https://git.sr.ht/~singpolyma/dhall-ruby