phlex 2.4.0.beta1 → 2.4.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66da2693f1133dc2ee688f43e91cca9ce2fb3537a3df44b364d89c653a4c85a0
-  data.tar.gz: 4148a9f44e78765e788758c61e38a681d47833a30d5e4a6e6cae1d99dbf61cb7
+  metadata.gz: 01002f30f11a82c8fce49ec63ce50cd3947c40a50d66c9fd02123c87a89f434c
+  data.tar.gz: 0b40acfa20d82bf9c7e6bb68c8aeca447731d56436b2876750bfc669e9ba52a4
 SHA512:
-  metadata.gz: 642bbd9e026528f5e5a8c505b6b8ff557e40ad90a9ac7ec8b83af85c32825f5963d31ce5c420b29658db8ffc0dbe337daae1f99cd42437db9d45500582be4a06
-  data.tar.gz: c4eb6e00e6424f381cbbdc0a68c4923f6d14b6296673d669a0fa4a3a7a3b411d247108590863f949e5801414d0bf0d2880a85c9d9931e03959188867a9a7737f
+  metadata.gz: 68d5a712386d7da44bb013ee956dde702d6e9f68e1cc237aac8a706a27cbff312dfd81a03405c9330f3109b87e7ff312711cf07a2e022ae1a256d984d60062cb
+  data.tar.gz: 9dd429c7d0a3d0b962ca1d6b653abd79260134c743f6322e87e90d3af200b188695cf8a2e3a6588ba2d731f6227f0c1ef1bb45b1bfd37f9ae2d6b02764a93d3a

data/lib/phlex/compiler/class_compiler.rb

@@ -1,23 +1,35 @@
 # frozen_string_literal: true
 
 class Phlex::Compiler::ClassCompiler < Refract::Visitor
-	def initialize(compiler)
+	def initialize(component, path)
 		super()
-		@compiler = compiler
+		@component = component
+		@path = path
 		@compiled_snippets = []
 	end
 
 	def compile(node)
 		visit(node.body)
-		@compiled_snippets.freeze
+		@compiled_snippets.compact.freeze
 	end
 
 	visit Refract::DefNode do |node|
 		return if node.name == :initialize
 		return if node.receiver
 
+		method = begin
+			Phlex::UNBOUND_INSTANCE_METHOD_METHOD.bind_call(@component, node.name)
+		rescue NameError
+			nil
+		end
+
+		return unless method
+		path, lineno = method.source_location
+		return unless @path == path
+		return unless node.start_line == lineno
+
 		@compiled_snippets << Phlex::Compiler::MethodCompiler.new(
-			@compiler.component
+			@component
 		).compile(node)
 	end
 

data/lib/phlex/compiler/compactor.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class Phlex::Compiler::Compactor < Refract::MutationVisitor
+	visit Refract::StatementsNode do |node|
+		queue = []
+		results = []
+		current_buffer = nil
+		nil_context = false
+
+		node.body.reverse_each { |n| queue << n }
+
+		while (child_node = queue.pop)
+			case child_node
+			when Refract::StatementsNode
+				child_node.body.reverse_each { |n| queue << n }
+			when Phlex::Compiler::Concat
+				if current_buffer
+					current_buffer << child_node.node
+					unless nil_context
+						results << Refract::NilNode.new
+						nil_context = true
+					end
+				else
+					current_buffer = [child_node.node]
+					results << Refract::ParenthesesNode.new(
+						body: Refract::StatementsNode.new(
+							body: [
+								Refract::IfNode.new(
+									inline: false,
+									predicate: Refract::LocalVariableReadNode.new(
+										name: :__phlex_should_render__
+									),
+									statements: Refract::StatementsNode.new(
+										body: [
+											Refract::CallNode.new(
+												receiver: Refract::CallNode.new(
+													name: :__phlex_buffer__,
+												),
+												name: :<<,
+												arguments: Refract::ArgumentsNode.new(
+													arguments: [
+														Refract::InterpolatedStringNode.new(
+															parts: current_buffer
+														),
+													]
+												)
+											),
+										]
+									)
+								),
+								Refract::NilNode.new,
+							]
+						)
+					)
+					nil_context = true
+				end
+			else
+				resolved = visit(child_node)
+				case resolved
+				when Refract::StatementsNode
+					resolved.body.reverse_each { |n| queue << n }
+				else
+					current_buffer = nil
+					results << resolved
+					nil_context = false
+				end
+			end
+		end
+
+		node.copy(
+			body: results
+		)
+	end
+end

data/lib/phlex/compiler/file_compiler.rb

@@ -3,16 +3,16 @@
 class Phlex::Compiler::FileCompiler < Refract::Visitor
 	Result = Data.define(:namespace, :compiled_snippets)
 
-	def initialize(compiler)
+	def initialize(path)
 		super()
-		@compiler = compiler
+		@path = path
 		@current_namespace = []
+		@results = []
 	end
 
 	def compile(node)
-		catch(:phlex_compiler_result) do
-			visit(node)
-		end
+		visit(node)
+		@results.freeze
 	end
 
 	visit Refract::ModuleNode do |node|
@@ -24,10 +24,16 @@ class Phlex::Compiler::FileCompiler < Refract::Visitor
 	visit Refract::ClassNode do |node|
 		@current_namespace.push(node)
 
-		if @compiler.line == node.start_line
-			throw :phlex_compiler_result, Result.new(
+		namespace = @current_namespace.map do |node|
+			Refract::Formatter.new.format_node(node.constant_path).source
+		end.join("::")
+
+		const = eval(namespace, TOPLEVEL_BINDING)
+
+		if Class === const && Phlex::SGML > const
+			@results << Result.new(
 				namespace: @current_namespace.dup.freeze,
-				compiled_snippets: Phlex::Compiler::ClassCompiler.new(@compiler).compile(node)
+				compiled_snippets: Phlex::Compiler::ClassCompiler.new(const, @path).compile(node)
 			)
 		else
 			super(node)

data/lib/phlex/compiler/method_compiler.rb

@@ -7,22 +7,20 @@ module Phlex::Compiler
 		def initialize(component)
 			super()
 			@component = component
-			@current_buffer = nil
 			@preamble = []
+			@optimized = false
 		end
 
 		def compile(node)
-			visit(node)
-		end
-
-		def around_visit(node)
-			result = super
-
-			# We want to clear the buffer when there’s a node that isn’t a statements node,
-			# but we should ignore nils, which are usually other buffers.
-			clear_buffer unless result in Refract::StatementsNode | nil
+			tree = visit(node)
 
-			result
+			if @optimized
+				Compactor.new.visit(
+					tree
+				)
+			else
+				nil
+			end
 		end
 
 		visit Refract::ClassNode do |node|
@@ -36,14 +34,49 @@ module Phlex::Compiler
 		visit Refract::DefNode do |node|
 			if @stack.size == 1
 				node.copy(
-					body: Refract::StatementsNode.new(
-						body: [
-							Refract::StatementsNode.new(
-								body: @preamble
+					body: Refract::BeginNode.new(
+						statements: Refract::StatementsNode.new(
+							body: [
+								Refract::StatementsNode.new(
+									body: @preamble
+								),
+								Refract::NilNode.new,
+								visit(node.body),
+							]
+						),
+						rescue_clause: Refract::RescueNode.new(
+							exceptions: [],
+							reference: Refract::LocalVariableTargetNode.new(
+								name: :__phlex_exception__
 							),
-							Refract::NilNode.new,
-							visit(node.body),
-						]
+							statements: Refract::StatementsNode.new(
+								body: [
+									Refract::CallNode.new(
+										receiver: Refract::ConstantReadNode.new(
+											name: :Kernel
+										),
+										name: :raise,
+										arguments: Refract::ArgumentsNode.new(
+											arguments: [
+												Refract::CallNode.new(
+													name: :__map_exception__,
+													arguments: Refract::ArgumentsNode.new(
+														arguments: [
+															Refract::LocalVariableReadNode.new(
+																name: :__phlex_exception__
+															),
+														]
+													)
+												),
+											]
+										)
+									),
+								]
+							),
+							subsequent: nil
+						),
+						else_clause: nil,
+						ensure_clause: nil
 					)
 				)
 			else
@@ -76,11 +109,15 @@ module Phlex::Compiler
 		end
 
 		visit Refract::BlockNode do |node|
-			node.copy(
-				body: compile_block_body_node(
-					node.body
+			if node.body
+				node.copy(
+					body: compile_block_body_node(
+						node.body
+					)
 				)
-			)
+			else
+				node
+			end
 		end
 
 		def compile_standard_element(node, tag)
@@ -88,19 +125,19 @@ module Phlex::Compiler
 
 			Refract::StatementsNode.new(
 				body: [
-					buffer("<#{tag}"),
+					raw("<#{tag}"),
 					*(
 						if node.arguments
 							compile_phlex_attributes(node.arguments)
 						end
 					),
-					buffer(">"),
+					raw(">"),
 					*(
 						if node.block
 							compile_phlex_block(node.block)
 						end
 					),
-					buffer("</#{tag}>"),
+					raw("</#{tag}>"),
 				]
 			)
 		end
@@ -110,13 +147,13 @@ module Phlex::Compiler
 
 			Refract::StatementsNode.new(
 				body: [
-					buffer("<#{tag}"),
+					raw("<#{tag}"),
 					*(
 						if node.arguments
 							compile_phlex_attributes(node.arguments)
 						end
 					),
-					buffer(">"),
+					raw(">"),
 				]
 			)
 		end
@@ -131,17 +168,16 @@ module Phlex::Compiler
 				end
 
 				if literal_attributes
-					return buffer(
+					return raw(
 						Phlex::SGML::Attributes.generate_attributes(
 							eval(
-								"{#{Refract::Formatter.new.format_node(node)}}"
+								"{#{Refract::Formatter.new.format_node(node).source}}",
+								TOPLEVEL_BINDING
 							)
 						)
 					)
 				end
 
-				clear_buffer
-
 				Refract::CallNode.new(
 					name: :__render_attributes__,
 					arguments: Refract::ArgumentsNode.new(
@@ -162,7 +198,7 @@ module Phlex::Compiler
 					content = node.body.body.first
 					case content
 					when Refract::StringNode, Refract::SymbolNode
-						return buffer(Phlex::Escape.html_escape(content.unescaped))
+						return plain(content.unescaped)
 					when Refract::InterpolatedStringNode
 						return compile_interpolated_string_node(content)
 					when Refract::NilNode
@@ -173,7 +209,6 @@ module Phlex::Compiler
 				end
 			end
 
-			clear_buffer
 			Refract::CallNode.new(
 				name: :__yield_content__,
 				block: node
@@ -181,7 +216,7 @@ module Phlex::Compiler
 		end
 
 		def compile_block_body_node(node)
-			node => Refract::StatementsNode
+			node => Refract::StatementsNode | Refract::BeginNode
 
 			Refract::StatementsNode.new(
 				body: [
@@ -216,7 +251,7 @@ module Phlex::Compiler
 				body: node.parts.map do |part|
 					case part
 					when Refract::StringNode
-						buffer(Phlex::Escape.html_escape(part.unescaped))
+						plain(part.unescaped)
 					when Refract::EmbeddedVariableNode
 						interpolate(part.variable)
 					when Refract::EmbeddedStatementsNode
@@ -234,27 +269,27 @@ module Phlex::Compiler
 			if node.block
 				Refract::StatementsNode.new(
 					body: [
-						buffer(" "),
+						raw(" "),
 						compile_phlex_block(node.block),
-						buffer(" "),
+						raw(" "),
 					]
 				)
 			else
-				buffer(" ")
+				raw(" ")
 			end
 		end
 
 		def compile_doctype_helper(node)
 			node => Refract::CallNode
 
-			buffer("<!doctype html>")
+			raw("<!doctype html>")
 		end
 
 		def compile_plain_helper(node)
 			node => Refract::CallNode
 
-			if node.arguments in [Refract::StringNode]
-				buffer(node.arguments.arguments.first.unescaped)
+			if node.arguments.arguments in [Refract::StringNode]
+				raw(node.arguments.arguments.first.unescaped)
 			else
 				node
 			end
@@ -306,51 +341,53 @@ module Phlex::Compiler
 
 			Refract::StatementsNode.new(
 				body: [
-					buffer("<!-- "),
+					raw("<!-- "),
 					compile_phlex_block(node.block),
-					buffer(" -->"),
+					raw(" -->"),
 				]
 			)
 		end
 
 		def compile_raw_helper(node)
 			node => Refract::CallNode
-
 			node
 		end
 
-		private def buffer(value)
-			if @current_buffer
-				@current_buffer << Refract::StringNode.new(
-					unescaped: value
-				)
+		private def plain(value)
+			value => String
+			raw(Phlex::Escape.html_escape(value))
+		end
 
-				nil
-			else
-				new_buffer = [
-					Refract::StringNode.new(
-						unescaped: value
-					),
-				]
+		private def raw(value)
+			value => String
 
-				@current_buffer = new_buffer
+			buffer(
+				Refract::StringNode.new(
+					unescaped: value
+				)
+			)
+		end
 
-				Refract::IfNode.new(
-					inline: false,
-					predicate: Refract::LocalVariableReadNode.new(
-						name: should_render_local
-					),
+		private def interpolate(statements)
+			buffer(
+				Refract::EmbeddedStatementsNode.new(
 					statements: Refract::StatementsNode.new(
 						body: [
 							Refract::CallNode.new(
-								receiver: Refract::CallNode.new(
-									name: buffer_local,
+								receiver: Refract::ConstantPathNode.new(
+									parent: Refract::ConstantPathNode.new(
+										name: "Phlex"
+									),
+									name: "Escape"
 								),
-								name: :<<,
+								name: :html_escape,
 								arguments: Refract::ArgumentsNode.new(
 									arguments: [
-										Refract::InterpolatedStringNode.new(
-											parts: new_buffer
+										Refract::CallNode.new(
+											receiver: Refract::ParenthesesNode.new(
+												body: statements
+											),
+											name: :to_s
 										),
 									]
 								)
@@ -358,76 +395,27 @@ module Phlex::Compiler
 						]
 					)
 				)
-			end
-		end
-
-		private def interpolate(statements, escape: true)
-			embedded_statement = Refract::EmbeddedStatementsNode.new(
-				statements: Refract::StatementsNode.new(
-					body: [
-						Refract::CallNode.new(
-							receiver: Refract::ConstantPathNode.new(
-								parent: Refract::ConstantPathNode.new(
-									name: "Phlex"
-								),
-								name: "Escape"
-							),
-							name: :html_escape,
-							arguments: Refract::ArgumentsNode.new(
-								arguments: [
-									Refract::CallNode.new(
-										receiver: Refract::ParenthesesNode.new(
-											body: statements
-										),
-										name: :to_s
-									),
-								]
-							)
-						),
-					]
-				)
 			)
+		end
 
-			if @current_buffer
-				@current_buffer << embedded_statement
-
-				nil
-			else
-				new_buffer = [embedded_statement]
+		private def buffer(node)
+			@optimized = true
+			node => Refract::StringNode | Refract::EmbeddedStatementsNode
 
-				@current_buffer = new_buffer
+			should_render_local
+			buffer_local
 
-				Refract::IfNode.new(
-					predicate: Refract::LocalVariableReadNode.new(
-						name: should_render_local
+			Refract::StatementsNode.new(
+				body: [
+					Concat.new(
+						node
 					),
-					statements: Refract::StatementsNode.new(
-						body: [
-							Refract::CallNode.new(
-								receiver: Refract::CallNode.new(
-									name: buffer_local,
-								),
-								name: :<<,
-								arguments: Refract::ArgumentsNode.new(
-									arguments: [
-										Refract::InterpolatedStringNode.new(
-											parts: new_buffer
-										),
-									]
-								)
-							),
-						]
-					)
-				)
-			end
-		end
-
-		private def clear_buffer
-			@current_buffer = nil
+				]
+			)
 		end
 
 		private def output_block?(node)
-			node.body.body.any? do |child|
+			node.body&.body&.any? do |child|
 				Refract::CallNode === child && (
 					standard_element?(child) ||
 					void_element?(child) ||
@@ -439,13 +427,13 @@ module Phlex::Compiler
 		end
 
 		private def static_content_block?(node)
-			return false unless node.body.body.length == 1
+			return false unless node.body&.body&.length == 1
 			node.body.body.first in Refract::StringNode | Refract::InterpolatedStringNode | Refract::SymbolNode | Refract::NilNode
 		end
 
 		private def standard_element?(node)
 			if (tag = Phlex::HTML::StandardElements.__registered_elements__[node.name]) &&
-					(Phlex::HTML::StandardElements == @component.instance_method(node.name).owner)
+					(Phlex::HTML::StandardElements == Phlex::UNBOUND_INSTANCE_METHOD_METHOD.bind_call(@component, node.name).owner)
 
 				tag
 			else
@@ -455,7 +443,7 @@ module Phlex::Compiler
 
 		private def void_element?(node)
 			if (tag = Phlex::HTML::VoidElements.__registered_elements__[node.name]) &&
-					(Phlex::HTML::VoidElements == @component.instance_method(node.name).owner)
+					(Phlex::HTML::VoidElements == Phlex::UNBOUND_INSTANCE_METHOD_METHOD.bind_call(@component, node.name).owner)
 
 				tag
 			else
@@ -521,7 +509,7 @@ module Phlex::Compiler
 
 		ALLOWED_OWNERS = Set[Phlex::SGML, Phlex::HTML, Phlex::SVG]
 		private def own_method_without_scope?(node)
-			ALLOWED_OWNERS.include?(@component.instance_method(node.name).owner)
+			ALLOWED_OWNERS.include?(Phlex::UNBOUND_INSTANCE_METHOD_METHOD.bind_call(@component, node.name).owner)
 		end
 
 		private def state_local

data/lib/phlex/compiler.rb

@@ -4,15 +4,56 @@ require "prism"
 require "refract"
 
 module Phlex::Compiler
+	MAP = {}
+	DEPENDENCIES = {}
+
 	Error = Class.new(StandardError)
 
+	Concat = Data.define(:node) do
+		def start_line = nil
+		def accept(visitor) = self
+	end
+
 	def self.compile(component)
 		path, line = Object.const_source_location(component.name)
-		return unless File.exist?(path)
+		compile_file(path)
+	end
+
+	def self.compile_file(path)
+		unless File.exist?(path)
+			raise ArgumentError, "Can’t compile #{path} because it doesn’t exist."
+		end
+
+		require(path)
+
 		source = File.read(path)
 		tree = Prism.parse(source).value
 		refract = Refract::Converter.new.visit(tree)
 
-		Compilation.new(component, path, line, source, refract).compile
+		last_line = source.count("\n")
+
+		starting_line = last_line + 1
+
+		results = FileCompiler.new(path).compile(refract)
+
+		result = Refract::StatementsNode.new(
+			body: results.map do |result|
+				result.namespace.reverse_each.reduce(
+					result.compiled_snippets
+				) do |body, scope|
+					scope.copy(
+						body: Refract::StatementsNode.new(
+							body: [body]
+						)
+					)
+				end
+			end
+		)
+
+		formatting_result = Refract::Formatter.new(starting_line:).format_node(result)
+
+		MAP[path] = formatting_result.source_map
+
+		eval("# frozen_string_literal: true\n#{formatting_result.source}", TOPLEVEL_BINDING, path, starting_line - 1)
 	end
 end

data/lib/phlex/sgml.rb

@@ -481,4 +481,18 @@ class Phlex::SGML
 		path, line = instance_method(method_name).source_location
 		Phlex::Compiler::Method.new(self, path, line, method_name).compile
 	end
+
+	def __map_exception__(exception)
+		exception.set_backtrace(
+			exception.backtrace_locations.map do |loc|
+				if ((map = Phlex::Compiler::MAP[loc.path]) && (line = map[loc.lineno]))
+					"[Phlex] #{loc.path}:#{line}:#{loc.label}"
+				else
+					"#{loc.path}:#{loc.lineno}:#{loc.label}"
+				end
+			end
+		)
+
+		exception
+	end
 end

data/lib/phlex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Phlex
-	VERSION = "2.4.0.beta1"
+	VERSION = "2.4.0.beta2"
 end

data/lib/phlex.rb

@@ -27,6 +27,8 @@ module Phlex
 	CACHED_FILES = Set.new
 	ATTRIBUTE_CACHE = FIFO.new
 
+	UNBOUND_INSTANCE_METHOD_METHOD = Module.instance_method(:instance_method)
+
 	def self.__expand_attribute_cache__(file_path)
 		unless CACHED_FILES.include?(file_path)
 			CACHED_FILES << file_path

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex
 version: !ruby/object:Gem::Version
-  version: 2.4.0.beta1
+  version: 2.4.0.beta2
 platform: ruby
 authors:
 - Joel Drapper
@@ -50,7 +50,7 @@ files:
 - lib/phlex.rb
 - lib/phlex/compiler.rb
 - lib/phlex/compiler/class_compiler.rb
-- lib/phlex/compiler/compilation.rb
+- lib/phlex/compiler/compactor.rb
 - lib/phlex/compiler/file_compiler.rb
 - lib/phlex/compiler/method_compiler.rb
 - lib/phlex/csv.rb

data/lib/phlex/compiler/compilation.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Phlex::Compiler
-	class Compilation
-		def initialize(component, path, line, source, tree)
-			@component = component
-			@path = path
-			@line = line
-			@source = source
-			@tree = tree
-			freeze
-		end
-
-		attr_reader :component, :line, :source, :path
-
-		def compile
-			result = FileCompiler.new(self).compile(@tree)
-
-			result.compiled_snippets.each do |snippet|
-				start_line = snippet.start_line
-
-				namespaced = result.namespace.reverse_each.reduce(snippet) do |body, scope|
-					start_line -= 1
-
-					scope.copy(
-						body: Refract::StatementsNode.new(
-							body: [body]
-						)
-					)
-				end
-
-				source = Refract::Formatter.new.format_node(namespaced)
-
-				redefine_method(
-					source,
-					start_line
-				)
-			end
-		end
-
-		def redefine_method(source, line)
-			eval("# frozen_string_literal: true\n#{source}", TOPLEVEL_BINDING, @path, line - 1)
-		end
-	end
-end