phlex 2.0.0.beta2 → 2.0.0.rc2

data/lib/phlex/html/void_elements.rb

@@ -2,71 +2,98 @@
 
 # Void HTML elements don't accept content and never have a closing tag.
 module Phlex::HTML::VoidElements
-	extend Phlex::Elements
+	extend Phlex::SGML::Elements
 
-	# @!method area(**attributes, &content)
-	# 	Outputs an `<area>` tag.
-	# 	@return [nil]
-	# 	@see https://developer.mozilla.org/docs/Web/HTML/Element/area
-	register_void_element :area
-
-	# @!method br(**attributes, &content)
-	# 	Outputs a `<br>` tag.
-	# 	@return [nil]
-	# 	@see https://developer.mozilla.org/docs/Web/HTML/Element/br
-	register_void_element :br
-
-	# @!method col(**attributes, &content)
-	# 	Outputs a `<col>` tag.
-	# 	@return [nil]
-	# 	@see https://developer.mozilla.org/docs/Web/HTML/Element/col
-	register_void_element :col
-
-	# @!method embed(**attributes, &content)
-	# 	Outputs an `<embed>` tag.
-	# 	@return [nil]
-	# 	@see https://developer.mozilla.org/docs/Web/HTML/Element/embed
-	register_void_element :embed
-
-	# @!method hr(**attributes, &content)
-	# 	Outputs an `<hr>` tag.
-	# 	@return [nil]
-	# 	@see https://developer.mozilla.org/docs/Web/HTML/Element/hr
-	register_void_element :hr
-
-	# @!method img(**attributes, &content)
-	# 	Outputs an `<img>` tag.
-	# 	@return [nil]
-	# 	@see https://developer.mozilla.org/docs/Web/HTML/Element/img
-	register_void_element :img
-
-	# @!method input(**attributes, &content)
-	# 	Outputs an `<input>` tag.
-	# 	@return [nil]
-	# 	@see https://developer.mozilla.org/docs/Web/HTML/Element/input
-	register_void_element :input
-
-	# @!method link(**attributes, &content)
-	# 	Outputs a `<link>` tag.
-	# 	@return [nil]
-	# 	@see https://developer.mozilla.org/docs/Web/HTML/Element/link
-	register_void_element :link
-
-	# @!method meta(**attributes, &content)
-	# 	Outputs a `<meta>` tag.
-	# 	@return [nil]
-	# 	@see https://developer.mozilla.org/docs/Web/HTML/Element/meta
-	register_void_element :meta
-
-	# @!method source(**attributes, &content)
-	# 	Outputs a `<source>` tag.
-	# 	@return [nil]
-	# 	@see https://developer.mozilla.org/docs/Web/HTML/Element/source
-	register_void_element :source
-
-	# @!method track(**attributes, &content)
-	# 	Outputs a `<track>` tag.
-	# 	@return [nil]
-	# 	@see https://developer.mozilla.org/docs/Web/HTML/Element/track
-	register_void_element :track
+	# Outputs an `<area>` tag.
+	# See https://developer.mozilla.org/docs/Web/HTML/Element/area
+	__register_void_element__ def area(
+		class: nil,
+		id: nil,
+		**attributes
+	) = nil
+	# Outputs a `<base>` tag.
+	# See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base
+	__register_void_element__ def base(
+		class: nil,
+		href: nil,
+		id: nil,
+		target: nil,
+		**attributes
+	) = nil
+	# Outputs a `<br>` tag.
+	# See https://developer.mozilla.org/docs/Web/HTML/Element/br
+	__register_void_element__ def br(
+		class: nil,
+		id: nil,
+		**attributes
+	) = nil
+	# Outputs a `<col>` tag.
+	# See https://developer.mozilla.org/docs/Web/HTML/Element/col
+	__register_void_element__ def col(
+		class: nil,
+		id: nil,
+		**attributes
+	) = nil
+	# Outputs an `<embed>` tag.
+	# See https://developer.mozilla.org/docs/Web/HTML/Element/embed
+	__register_void_element__ def embed(
+		class: nil,
+		id: nil,
+		**attributes
+	) = nil
+	# Outputs an `<hr>` tag.
+	# See https://developer.mozilla.org/docs/Web/HTML/Element/hr
+	__register_void_element__ def hr(
+		class: nil,
+		id: nil,
+		**attributes
+	) = nil
+	# Outputs an `<img>` tag.
+	# See https://developer.mozilla.org/docs/Web/HTML/Element/img
+	__register_void_element__ def img(
+		alt: nil,
+		class: nil,
+		id: nil,
+		src: nil,
+		**attributes
+	) = nil
+	# Outputs an `<input>` tag.
+	# See https://developer.mozilla.org/docs/Web/HTML/Element/input
+	__register_void_element__ def input(
+		class: nil,
+		id: nil,
+		name: nil,
+		type: nil,
+		**attributes
+	) = nil
+	# Outputs a `<link>` tag.
+	# See https://developer.mozilla.org/docs/Web/HTML/Element/link
+	__register_void_element__ def link(
+		class: nil,
+		id: nil,
+		**attributes
+	) = nil
+	# Outputs a `<meta>` tag.
+	# See https://developer.mozilla.org/docs/Web/HTML/Element/meta
+	__register_void_element__ def meta(
+		charset: nil,
+		class: nil,
+		id: nil,
+		name: nil,
+		**attributes
+	) = nil
+	# Outputs a `<source>` tag.
+	# See https://developer.mozilla.org/docs/Web/HTML/Element/source
+	__register_void_element__ def source(
+		class: nil,
+		id: nil,
+		**attributes
+	) = nil
+	# Outputs a `<track>` tag.
+	# See https://developer.mozilla.org/docs/Web/HTML/Element/track
+	__register_void_element__ def track(
+		class: nil,
+		id: nil,
+		**attributes
+	) = nil
 end

data/lib/phlex/html.rb

@@ -4,18 +4,15 @@ class Phlex::HTML < Phlex::SGML
 	autoload :StandardElements, "phlex/html/standard_elements"
 	autoload :VoidElements, "phlex/html/void_elements"
 
-	# A list of HTML attributes that have the potential to execute unsafe JavaScript.
-	UNSAFE_ATTRIBUTES = Set.new(%w[onabort onafterprint onbeforeprint onbeforeunload onblur oncanplay oncanplaythrough onchange onclick oncontextmenu oncopy oncuechange oncut ondblclick ondrag ondragend ondragenter ondragleave ondragover ondragstart ondrop ondurationchange onemptied onended onerror onfocus onhashchange oninput oninvalid onkeydown onkeypress onkeyup onload onloadeddata onloadedmetadata onloadstart onmessage onmousedown onmousemove onmouseout onmouseover onmouseup onmousewheel onoffline ononline onpagehide onpageshow onpaste onpause onplay onplaying onpopstate onprogress onratechange onreset onresize onscroll onsearch onseeked onseeking onselect onstalled onstorage onsubmit onsuspend ontimeupdate ontoggle onunload onvolumechange onwaiting onwheel srcdoc]).freeze
-
-	extend Phlex::Elements
+	extend Phlex::SGML::Elements
 	include VoidElements, StandardElements
 
 	# Output an HTML doctype.
 	def doctype
-		context = @_context
-		return if context.fragments && !context.in_target_fragment
+		state = @_state
+		return unless state.should_render?
 
-		context.buffer << "<!doctype html>"
+		state.buffer << "<!doctype html>"
 		nil
 	end
 
@@ -41,7 +38,4 @@ class Phlex::HTML < Phlex::SGML
 	def content_type
 		"text/html"
 	end
-
-	# This should be extended after all method definitions
-	extend Phlex::ElementClobberingGuard
 end

data/lib/phlex/kit.rb

@@ -3,7 +3,9 @@
 module Phlex::Kit
 	module LazyLoader
 		def method_missing(name, ...)
-			if name[0] == name[0].upcase && __phlex_kit_constants__.include?(name) && __get_phlex_kit_constant__(name) && methods.include?(name)
+			mod = self.class
+
+			if name[0] == name[0].upcase && mod.constants.include?(name) && mod.const_get(name) && methods.include?(name)
 				public_send(name, ...)
 			else
 				super
@@ -11,7 +13,9 @@ module Phlex::Kit
 		end
 
 		def respond_to_missing?(name, include_private = false)
-			if name[0] == name[0].upcase && __phlex_kit_constants__.include?(name) && __get_phlex_kit_constant__(name) && methods.include?(name)
+			mod = self.class
+
+			if name[0] == name[0].upcase && mod.constants.include?(name) && mod.const_get(name) && methods.include?(name)
 				true
 			else
 				super
@@ -19,20 +23,24 @@ module Phlex::Kit
 		end
 	end
 
-	include LazyLoader
-
 	def self.extended(mod)
 		mod.include(LazyLoader)
-		mod.define_method(:__phlex_kit_constants__) { mod.__phlex_kit_constants__ }
-		mod.define_method(:__get_phlex_kit_constant__) { |name| mod.__get_phlex_kit_constant__(name) }
 	end
 
-	def __phlex_kit_constants__
-		constants
+	def method_missing(name, ...)
+		if name[0] == name[0].upcase && constants.include?(name) && const_get(name) && methods.include?(name)
+			public_send(name, ...)
+		else
+			super
+		end
 	end
 
-	def __get_phlex_kit_constant__(name)
-		const_get(name)
+	def respond_to_missing?(name, include_private = false)
+		if name[0] == name[0].upcase && constants.include?(name) && const_get(name) && methods.include?(name)
+			true
+		else
+			super
+		end
 	end
 
 	def const_added(name)
@@ -41,23 +49,32 @@ module Phlex::Kit
 		me = self
 		constant = const_get(name)
 
-		if Class === constant && constant < Phlex::SGML
-			constant.include(self)
+		case constant
+		when Class
+			if constant < Phlex::SGML
+				constant.include(self)
 
-			define_method(name) do |*args, **kwargs, &block|
-				constant = me.const_get(name)
-				render(constant.new(*args, **kwargs), &block)
-			end
+				constant = nil
+
+				define_method(name) do |*args, **kwargs, &block|
+					constant = me.const_get(name)
+					render(constant.new(*args, **kwargs), &block)
+				end
 
-			define_singleton_method(name) do |*args, **kwargs, &block|
-				if (component = Fiber[:__phlex_component__])
-					component.instance_exec do
-						render(constant.new(*args, **kwargs), &block)
+				define_singleton_method(name) do |*args, **kwargs, &block|
+					component, fiber_id = Thread.current[:__phlex_component__]
+					if (component && fiber_id == Fiber.current.object_id)
+						component.instance_exec do
+							constant = me.const_get(name)
+							render(constant.new(*args, **kwargs), &block)
+						end
+					else
+						raise "You can't call `#{name}' outside of a Phlex rendering context."
 					end
-				else
-					raise "You can't call `#{name}' outside of a Phlex rendering context."
 				end
 			end
+		when Module
+			constant.extend(Phlex::Kit)
 		end
 
 		super

data/lib/phlex/null_cache_store.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Phlex::NullCacheStore
+	extend self
+
+	def fetch(key)
+		yield
+	end
+end

data/lib/phlex/sgml/elements.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Phlex::SGML::Elements
+	def __registered_elements__
+		@__registered_elements__ ||= {}
+	end
+
+	def register_element(method_name, tag: method_name.name.tr("_", "-"))
+		class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+			# frozen_string_literal: true
+
+			def #{method_name}(**attributes)
+				state = @_state
+				buffer = state.buffer
+				block_given = block_given?
+
+				unless state.should_render?
+					yield(self) if block_given
+					return nil
+				end
+
+				if attributes.length > 0 # with attributes
+					if block_given # with content block
+						buffer << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes] ||= __attributes__(attributes)) << ">"
+
+						original_length = buffer.bytesize
+						content = yield(self)
+						if original_length == buffer.bytesize
+							case content
+							when nil
+								nil
+							when String
+								buffer << ::Phlex::Escape.html_escape(content)
+							when Symbol
+								buffer << ::Phlex::Escape.html_escape(content.name)
+							when ::Phlex::SGML::SafeObject
+								buffer << content.to_s
+							else
+								if (formatted_object = format_object(content))
+									buffer << ::Phlex::Escape.html_escape(formatted_object)
+								end
+							end
+						end
+
+						buffer << "</#{tag}>"
+					else # without content
+						buffer << "<#{tag}" << (::Phlex::ATTRIBUTE_CACHE[attributes] ||= __attributes__(attributes)) << "></#{tag}>"
+					end
+				else # without attributes
+					if block_given # with content block
+						buffer << "<#{tag}>"
+
+						original_length = buffer.bytesize
+						content = yield(self)
+						if original_length == buffer.bytesize
+							case content
+							when nil
+								nil
+							when String
+								buffer << ::Phlex::Escape.html_escape(content)
+							when Symbol
+								buffer << ::Phlex::Escape.html_escape(content.name)
+							when ::Phlex::SGML::SafeObject
+								buffer << content.to_s
+							else
+								if (formatted_object = format_object(content))
+									buffer << ::Phlex::Escape.html_escape(formatted_object)
+								end
+							end
+						end
+
+						buffer << "</#{tag}>"
+					else # without content
+						buffer << "<#{tag}></#{tag}>"
+					end
+				end
+
+				#{'flush' if tag == 'head'}
+
+				nil
+			end
+		RUBY
+
+		__registered_elements__[method_name] = tag
+
+		method_name
+	end
+
+	def __register_void_element__(method_name, tag: method_name.name.tr("_", "-"))
+		class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+			# frozen_string_literal: true
+
+			def #{method_name}(**attributes)
+				state = @_state
+
+				return unless state.should_render?
+
+				if attributes.length > 0 # with attributes
+					state.buffer << "<#{tag}" << (::Phlex::ATTRIBUTE_CACHE[attributes] ||= __attributes__(attributes)) << ">"
+				else # without attributes
+					state.buffer << "<#{tag}>"
+				end
+
+				nil
+			end
+		RUBY
+
+		__registered_elements__[method_name] = tag
+
+		method_name
+	end
+end

data/lib/phlex/sgml/state.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+class Phlex::SGML::State
+	def initialize(user_context: {}, view_context: nil, output_buffer:, fragments:)
+		@buffer = +""
+		@capturing = false
+		@user_context = user_context
+		@fragments = fragments
+		@fragment_depth = 0
+		@cache_stack = []
+		@halt_signal = nil
+		@view_context = view_context
+		@output_buffer = output_buffer
+	end
+
+	attr_accessor :buffer, :capturing, :user_context
+
+	attr_reader :fragments, :fragment_depth, :view_context, :output_buffer
+
+	def around_render(component)
+		stack = @stack
+
+		if !@fragments || @halt_signal
+			yield
+		else
+			catch do |signal|
+				@halt_signal = signal
+				yield
+			end
+		end
+	end
+
+	def should_render?
+		!@fragments || @fragment_depth > 0
+	end
+
+	def begin_fragment(id)
+		@fragment_depth += 1 if @fragments&.include?(id)
+
+		if caching?
+			current_byte_offset = 0                                 		# Start tracking the byte offset of this fragment from the start of the cache buffer
+			@cache_stack.reverse_each do |(cache_buffer, fragment_map)| # We'll iterate deepest to shallowest
+				current_byte_offset += cache_buffer.bytesize		      		# Add the length of the cache buffer to the current byte offset
+				fragment_map[id] = [current_byte_offset, nil, []]     		# Record the byte offset, length, and store a list of the nested fragments
+
+				fragment_map.each do |name, (_offset, length, nested_fragments)| # Iterate over the other fragments
+					next if name == id || length                       						 # Skip if it's the current fragment, or if the fragment has already ended
+					nested_fragments << id                                       	 # Add the current fragment to the list of nested fragments
+				end
+			end
+		end
+	end
+
+	def end_fragment(id)
+		if caching?
+			byte_length = nil
+			@cache_stack.reverse_each do |(cache_buffer, fragment_map)|   # We'll iterate deepest to shallowest
+				byte_length ||= cache_buffer.bytesize - fragment_map[id][0] # The byte length is the difference between the current byte offset and the byte offset of the fragment
+				fragment_map[id][1] = byte_length                           # All cache contexts will use the same by
+			end
+		end
+
+		return unless @fragments&.include?(id)
+
+		@fragments.delete(id)
+		@fragment_depth -= 1
+		throw @halt_signal if @fragments.length == 0
+	end
+
+	def record_fragment(id, offset, length, nested_fragments)
+		return unless caching?
+
+		@cache_stack.reverse_each do |(cache_buffer, fragment_map)|
+			offset += cache_buffer.bytesize
+			fragment_map[id] = [offset, length, nested_fragments]
+		end
+	end
+
+	def caching(&)
+		buffer = +""
+		@cache_stack.push([buffer, {}].freeze)
+		capturing_into(buffer, &)
+		@cache_stack.pop
+	end
+
+	def caching?
+		@cache_stack.length > 0
+	end
+
+	def capturing_into(new_buffer)
+		original_buffer = @buffer
+		original_capturing = @capturing
+		original_fragments = @fragments
+
+		begin
+			@buffer = new_buffer
+			@capturing = true
+			@fragments = nil
+			yield
+		ensure
+			@buffer = original_buffer
+			@capturing = original_capturing
+			@fragments = original_fragments
+		end
+
+		new_buffer
+	end
+
+	def flush
+		return if capturing
+
+		buffer = @buffer
+		@output_buffer << buffer.dup
+
+		buffer.clear
+		nil
+	end
+end