phlex 2.3.1 → 2.4.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 534f2cde723f1707d19c32e8f23b06aa740cc0adaf62187318355eba8d8fdbea
-  data.tar.gz: de396ffb79b471cd9c72d3099a66de40411184aa7ff03c6285dc9b5ace50b589
+  metadata.gz: 66da2693f1133dc2ee688f43e91cca9ce2fb3537a3df44b364d89c653a4c85a0
+  data.tar.gz: 4148a9f44e78765e788758c61e38a681d47833a30d5e4a6e6cae1d99dbf61cb7
 SHA512:
-  metadata.gz: 707f796517d40bd0e763b3cfb00f8a10a1f7502598b0535e309b7689debcdb189a0ed49ec48928f3587e8bd724e6f2549becf68a7a3c7a0b5da9564f2543435a
-  data.tar.gz: 790bd859f956ef99102d0bd1deabea6af89ad7c3f2268cd2522d84f6f4d0ded6c8d94c5cfe18ee3777afce2972234d851c1d58b991d491d5e2fb5f6f1e206020
+  metadata.gz: 642bbd9e026528f5e5a8c505b6b8ff557e40ad90a9ac7ec8b83af85c32825f5963d31ce5c420b29658db8ffc0dbe337daae1f99cd42437db9d45500582be4a06
+  data.tar.gz: c4eb6e00e6424f381cbbdc0a68c4923f6d14b6296673d669a0fa4a3a7a3b411d247108590863f949e5801414d0bf0d2880a85c9d9931e03959188867a9a7737f

data/lib/phlex/compiler/class_compiler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Phlex::Compiler::ClassCompiler < Refract::Visitor
+	def initialize(compiler)
+		super()
+		@compiler = compiler
+		@compiled_snippets = []
+	end
+
+	def compile(node)
+		visit(node.body)
+		@compiled_snippets.freeze
+	end
+
+	visit Refract::DefNode do |node|
+		return if node.name == :initialize
+		return if node.receiver
+
+		@compiled_snippets << Phlex::Compiler::MethodCompiler.new(
+			@compiler.component
+		).compile(node)
+	end
+
+	visit Refract::ClassNode do |node|
+		nil
+	end
+
+	visit Refract::ModuleNode do |node|
+		nil
+	end
+
+	visit Refract::BlockNode do |node|
+		nil
+	end
+end

data/lib/phlex/compiler/compilation.rb

@@ -0,0 +1,45 @@
+# 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

data/lib/phlex/compiler/file_compiler.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Phlex::Compiler::FileCompiler < Refract::Visitor
+	Result = Data.define(:namespace, :compiled_snippets)
+
+	def initialize(compiler)
+		super()
+		@compiler = compiler
+		@current_namespace = []
+	end
+
+	def compile(node)
+		catch(:phlex_compiler_result) do
+			visit(node)
+		end
+	end
+
+	visit Refract::ModuleNode do |node|
+		@current_namespace.push(node)
+		super(node)
+		@current_namespace.pop
+	end
+
+	visit Refract::ClassNode do |node|
+		@current_namespace.push(node)
+
+		if @compiler.line == node.start_line
+			throw :phlex_compiler_result, Result.new(
+				namespace: @current_namespace.dup.freeze,
+				compiled_snippets: Phlex::Compiler::ClassCompiler.new(@compiler).compile(node)
+			)
+		else
+			super(node)
+		end
+
+		@current_namespace.pop
+	end
+
+	visit Refract::DefNode do |node|
+		nil
+	end
+
+	visit Refract::BlockNode do |node|
+		nil
+	end
+end

data/lib/phlex/compiler/method_compiler.rb

@@ -0,0 +1,591 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Phlex::Compiler
+	class MethodCompiler < Refract::MutationVisitor
+		def initialize(component)
+			super()
+			@component = component
+			@current_buffer = nil
+			@preamble = []
+		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
+
+			result
+		end
+
+		visit Refract::ClassNode do |node|
+			node
+		end
+
+		visit Refract::ModuleNode do |node|
+			node
+		end
+
+		visit Refract::DefNode do |node|
+			if @stack.size == 1
+				node.copy(
+					body: Refract::StatementsNode.new(
+						body: [
+							Refract::StatementsNode.new(
+								body: @preamble
+							),
+							Refract::NilNode.new,
+							visit(node.body),
+						]
+					)
+				)
+			else
+				node
+			end
+		end
+
+		visit Refract::CallNode do |node|
+			if nil == node.receiver
+				if (tag = standard_element?(node))
+					return compile_standard_element(node, tag)
+				elsif (tag = void_element?(node))
+					return compile_void_element(node, tag)
+				elsif whitespace_helper?(node)
+					return compile_whitespace_helper(node)
+				elsif doctype_helper?(node)
+					return compile_doctype_helper(node)
+				elsif plain_helper?(node)
+					return compile_plain_helper(node)
+				elsif fragment_helper?(node)
+					return compile_fragment_helper(node)
+				elsif comment_helper?(node)
+					return compile_comment_helper(node)
+				elsif raw_helper?(node)
+					return compile_raw_helper(node)
+				end
+			end
+
+			super(node)
+		end
+
+		visit Refract::BlockNode do |node|
+			node.copy(
+				body: compile_block_body_node(
+					node.body
+				)
+			)
+		end
+
+		def compile_standard_element(node, tag)
+			node => Refract::CallNode
+
+			Refract::StatementsNode.new(
+				body: [
+					buffer("<#{tag}"),
+					*(
+						if node.arguments
+							compile_phlex_attributes(node.arguments)
+						end
+					),
+					buffer(">"),
+					*(
+						if node.block
+							compile_phlex_block(node.block)
+						end
+					),
+					buffer("</#{tag}>"),
+				]
+			)
+		end
+
+		def compile_void_element(node, tag)
+			node => Refract::CallNode
+
+			Refract::StatementsNode.new(
+				body: [
+					buffer("<#{tag}"),
+					*(
+						if node.arguments
+							compile_phlex_attributes(node.arguments)
+						end
+					),
+					buffer(">"),
+				]
+			)
+		end
+
+		def compile_phlex_attributes(node)
+			arguments = node.arguments
+
+			if arguments.size == 1 && Refract::KeywordHashNode === (first_argument = arguments[0])
+				attributes = first_argument.elements
+				literal_attributes = attributes.all? do |attribute|
+					Refract::AssocNode === attribute && static_attribute_value_literal?(attribute)
+				end
+
+				if literal_attributes
+					return buffer(
+						Phlex::SGML::Attributes.generate_attributes(
+							eval(
+								"{#{Refract::Formatter.new.format_node(node)}}"
+							)
+						)
+					)
+				end
+
+				clear_buffer
+
+				Refract::CallNode.new(
+					name: :__render_attributes__,
+					arguments: Refract::ArgumentsNode.new(
+						arguments: [
+							node,
+						]
+					)
+				)
+			end
+		end
+
+		def compile_phlex_block(node)
+			case node
+			when Refract::BlockNode
+				if output_block?(node)
+					return visit(node.body)
+				elsif static_content_block?(node)
+					content = node.body.body.first
+					case content
+					when Refract::StringNode, Refract::SymbolNode
+						return buffer(Phlex::Escape.html_escape(content.unescaped))
+					when Refract::InterpolatedStringNode
+						return compile_interpolated_string_node(content)
+					when Refract::NilNode
+						return nil
+					else
+						raise
+					end
+				end
+			end
+
+			clear_buffer
+			Refract::CallNode.new(
+				name: :__yield_content__,
+				block: node
+			)
+		end
+
+		def compile_block_body_node(node)
+			node => Refract::StatementsNode
+
+			Refract::StatementsNode.new(
+				body: [
+					Refract::IfNode.new(
+						inline: false,
+						predicate: Refract::CallNode.new(
+							receiver: Refract::SelfNode.new,
+							name: :==,
+							arguments: Refract::ArgumentsNode.new(
+								arguments: [
+									Refract::LocalVariableReadNode.new(
+										name: self_local
+									),
+								]
+							)
+						),
+						statements: Refract::StatementsNode.new(
+							body: node.body.map { |n| visit(n) }
+						),
+						subsequent: Refract::ElseNode.new(
+							statements: node
+						)
+					),
+				]
+			)
+		end
+
+		def compile_interpolated_string_node(node)
+			node => Refract::InterpolatedStringNode
+
+			Refract::StatementsNode.new(
+				body: node.parts.map do |part|
+					case part
+					when Refract::StringNode
+						buffer(Phlex::Escape.html_escape(part.unescaped))
+					when Refract::EmbeddedVariableNode
+						interpolate(part.variable)
+					when Refract::EmbeddedStatementsNode
+						interpolate(part.statements)
+					else
+						raise Phlex::Compiler::Error, "Unexpected node type in InterpolatedStringNode: #{part.class}"
+					end
+				end
+			)
+		end
+
+		def compile_whitespace_helper(node)
+			node => Refract::CallNode
+
+			if node.block
+				Refract::StatementsNode.new(
+					body: [
+						buffer(" "),
+						compile_phlex_block(node.block),
+						buffer(" "),
+					]
+				)
+			else
+				buffer(" ")
+			end
+		end
+
+		def compile_doctype_helper(node)
+			node => Refract::CallNode
+
+			buffer("<!doctype html>")
+		end
+
+		def compile_plain_helper(node)
+			node => Refract::CallNode
+
+			if node.arguments in [Refract::StringNode]
+				buffer(node.arguments.arguments.first.unescaped)
+			else
+				node
+			end
+		end
+
+		def compile_fragment_helper(node)
+			node => Refract::CallNode
+
+			node.copy(
+				block: compile_fragment_helper_block(node.block)
+			)
+		end
+
+		def compile_fragment_helper_block(node)
+			node => Refract::BlockNode
+
+			node.copy(
+				body: Refract::StatementsNode.new(
+					body: [
+						Refract::LocalVariableWriteNode.new(
+							name: :__phlex_original_should_render__,
+							value: Refract::LocalVariableReadNode.new(
+								name: should_render_local
+							)
+						),
+						Refract::LocalVariableWriteNode.new(
+							name: should_render_local,
+							value: Refract::CallNode.new(
+								receiver: Refract::LocalVariableReadNode.new(
+									name: state_local
+								),
+								name: :should_render?
+							)
+						),
+						visit(node.body),
+						Refract::LocalVariableWriteNode.new(
+							name: should_render_local,
+							value: Refract::LocalVariableReadNode.new(
+								name: :__phlex_original_should_render__
+							)
+						),
+					]
+				)
+			)
+		end
+
+		def compile_comment_helper(node)
+			node => Refract::CallNode
+
+			Refract::StatementsNode.new(
+				body: [
+					buffer("<!-- "),
+					compile_phlex_block(node.block),
+					buffer(" -->"),
+				]
+			)
+		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
+				)
+
+				nil
+			else
+				new_buffer = [
+					Refract::StringNode.new(
+						unescaped: value
+					),
+				]
+
+				@current_buffer = new_buffer
+
+				Refract::IfNode.new(
+					inline: false,
+					predicate: Refract::LocalVariableReadNode.new(
+						name: should_render_local
+					),
+					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 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
+									),
+								]
+							)
+						),
+					]
+				)
+			)
+
+			if @current_buffer
+				@current_buffer << embedded_statement
+
+				nil
+			else
+				new_buffer = [embedded_statement]
+
+				@current_buffer = new_buffer
+
+				Refract::IfNode.new(
+					predicate: Refract::LocalVariableReadNode.new(
+						name: should_render_local
+					),
+					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|
+				Refract::CallNode === child && (
+					standard_element?(child) ||
+					void_element?(child) ||
+					plain_helper?(child) ||
+					whitespace_helper?(child) ||
+					raw_helper?(child)
+				)
+			end
+		end
+
+		private def static_content_block?(node)
+			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)
+
+				tag
+			else
+				false
+			end
+		end
+
+		private def void_element?(node)
+			if (tag = Phlex::HTML::VoidElements.__registered_elements__[node.name]) &&
+					(Phlex::HTML::VoidElements == @component.instance_method(node.name).owner)
+
+				tag
+			else
+				false
+			end
+		end
+
+		private def static_attribute_value_literal?(value)
+			case value
+			when Refract::SymbolNode, Refract::StringNode, Refract::IntegerNode, Refract::FloatNode, Refract::TrueNode, Refract::FalseNode, Refract::NilNode
+				true
+			when Refract::ArrayNode
+				value.elements.all? { |n| static_token_value_literal?(n) }
+			when Refract::HashNode
+				value.elements.all? { |n| static_attribute_value_literal?(n) }
+			when Refract::AssocNode
+				(Refract::StringNode === value.key || Refract::SymbolNode === value.key) && static_attribute_value_literal?(value.value)
+			when Refract::CallNode
+				if value in { receiver: Prism::ConstantReadNode[name: :Set]| Prism::ConstantPathNode[name: :Set, parent: nil], name: :[] }
+					value.arguments.arguments.all? { |n| static_token_value_literal?(n) }
+				else
+					false
+				end
+			else
+				false
+			end
+		end
+
+		private def static_token_value_literal?(value)
+			case value
+			when Prism::SymbolNode, Prism::StringNode, Prism::IntegerNode, Prism::FloatNode, Prism::NilNode
+				true
+			when Prism::ArrayNode
+				value.elements.all? { |n| static_token_value_literal?(n) }
+			else
+				false
+			end
+		end
+
+		private def whitespace_helper?(node)
+			node.name == :whitespace && own_method_without_scope?(node)
+		end
+
+		private def doctype_helper?(node)
+			node.name == :doctype && own_method_without_scope?(node)
+		end
+
+		private def plain_helper?(node)
+			node.name == :plain && own_method_without_scope?(node)
+		end
+
+		private def fragment_helper?(node)
+			node.name == :fragment && own_method_without_scope?(node)
+		end
+
+		private def comment_helper?(node)
+			node.name == :comment && own_method_without_scope?(node)
+		end
+
+		private def raw_helper?(node)
+			node.name == :raw && own_method_without_scope?(node)
+		end
+
+		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)
+		end
+
+		private def state_local
+			:__phlex_state__.tap do |local|
+				unless @state_local_set
+					@preamble << Refract::LocalVariableWriteNode.new(
+						name: local,
+						value: Refract::InstanceVariableReadNode.new(
+							name: :@_state
+						)
+					)
+
+					@state_local_set = true
+				end
+			end
+		end
+
+		private def buffer_local
+			:__phlex_buffer__.tap do |local|
+				unless @buffer_local_set
+					@preamble << Refract::LocalVariableWriteNode.new(
+						name: local,
+						value: Refract::CallNode.new(
+							receiver: Refract::LocalVariableReadNode.new(
+								name: state_local
+							),
+							name: :buffer,
+						)
+					)
+
+					@buffer_local_set = true
+				end
+			end
+		end
+
+		private def self_local
+			:__phlex_self__.tap do |local|
+				unless @self_local_set
+					@preamble << Refract::LocalVariableWriteNode.new(
+						name: local,
+						value: Refract::SelfNode.new
+					)
+
+					@self_local_set = true
+				end
+			end
+		end
+
+		private def should_render_local
+			:__phlex_should_render__.tap do |local|
+				unless @should_render_local_set
+					@preamble << Refract::LocalVariableWriteNode.new(
+						name: :__phlex_should_render__,
+						value: Refract::CallNode.new(
+							receiver: Refract::LocalVariableReadNode.new(
+								name: state_local
+							),
+							name: :should_render?
+						)
+					)
+
+					@should_render_local_set = true
+				end
+			end
+		end
+	end
+end