phlex 1.5.1 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 647e5f1a1f3beb8dd596cb87a5fb848f07e8e87e28ce705f3d1c93d8c9cfe9ac
-  data.tar.gz: d2b327f45d36a44069cf6dd9de03310918f56647bc1a40c6eb675837eb1cb653
+  metadata.gz: ada5b83ea9c2fbd305a249ffa81a43c9e9da26a7c87860dac62e594a43341001
+  data.tar.gz: e728f6c83cae97671bf4092f7bd384c93611d51158f613a75518d1109a669942
 SHA512:
-  metadata.gz: '0387ae5e9183fb312619950e5a5a6d75d1383c58e46be6f389e781a5cbdf2b3658efc4cbd298eb7b9d1ad0f9042c857ecc11c3812a2bd1600ee04a79f9fc1d8a'
-  data.tar.gz: 6159fbe6ac1f52baf8924e9309a43ae252a47655f7feaf380787fb4d5a56e83380154dd906e8a964b0754fa0f4827e3e3b028ca9f4a03ded5aace8431edf0452
+  metadata.gz: 6f8b512d89247318f657482d3eeb1ba9fd0c1de73edcf4f3c5d0b6ff843bbd0bbca6d47d9a957780a1831e70b67ec8c2d1d1beba10a00bc9546a8966f67d545d
+  data.tar.gz: a5a780a277bc36e8fa028af0ccdd3b985189ae6c49241d737b9d86e4f37fa43bbbfc8e4cb1736914735a35821a741c8fcc964f45c8b82b96c5389053c72b2684

data/lib/phlex/context.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Phlex::Context
+	def initialize
+		@target = +""
+	end
+
+	attr_accessor :target
+
+	def with_target(new_target)
+		original_target = @target
+
+		begin
+			@target = new_target
+			yield
+		ensure
+			@target = original_target
+		end
+
+		new_target
+	end
+end

data/lib/phlex/element_clobbering_guard.rb

@@ -3,11 +3,11 @@
 module Phlex
 	module ElementClobberingGuard
 		def method_added(method_name)
-			if method_name[0] == "_" && private_instance_methods.include?(:"__phlex#{method_name}__")
+			if method_name[0] == "_" && element_method?(method_name[1..].to_sym)
 				raise NameError, "👋 Redefining the method `#{name}##{method_name}` is not a good idea."
+			else
+				super
 			end
-
-			super
 		end
 	end
 end

data/lib/phlex/elements.rb

@@ -5,45 +5,44 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.0")
 end
 
 module Phlex::Elements
-	private def slow_registered_elements
-		private_instance_methods
-			.lazy
-			.map(&:to_s)
-			.select { |m| m.start_with?("__phlex_") }
-			.map { |m| m[8...-2].to_sym }
+	def registered_elements
+		@registered_elements ||= Concurrent::Map.new
 	end
 
 	def register_element(element, tag: element.name.tr("_", "-"))
 		class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
 			# frozen_string_literal: true
 
-			def __phlex_#{element}__(**attributes, &block)
+
+			def #{element}(**attributes, &block)
+				target = @_context.target
+
 				if attributes.length > 0 # with attributes
 					if block_given? # with content block
-						@_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[respond_to?(:process_attributes) ? (attributes.hash + self.class.hash) : attributes.hash] || __attributes__(**attributes)) << ">"
+						target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[respond_to?(:process_attributes) ? (attributes.hash + self.class.hash) : attributes.hash] || __attributes__(**attributes)) << ">"
 						yield_content(&block)
-						@_target << "</#{tag}>"
+						target << "</#{tag}>"
 					else # without content block
-						@_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[respond_to?(:process_attributes) ? (attributes.hash + self.class.hash) : attributes.hash] || __attributes__(**attributes)) << "></#{tag}>"
+						target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[respond_to?(:process_attributes) ? (attributes.hash + self.class.hash) : attributes.hash] || __attributes__(**attributes)) << "></#{tag}>"
 					end
 				else # without attributes
 					if block_given? # with content block
-						@_target << "<#{tag}>"
+						target << "<#{tag}>"
 						yield_content(&block)
-						@_target << "</#{tag}>"
+						target << "</#{tag}>"
 					else # without content block
-						@_target << "<#{tag}></#{tag}>"
+						target << "<#{tag}></#{tag}>"
 					end
 				end
 
 				nil
 			end
 
-			alias_method :_#{element}, :__phlex_#{element}__
-			alias_method :#{element}, :__phlex_#{element}__
-			private :__phlex_#{element}__
+			alias_method :_#{element}, :#{element}
 		RUBY
 
+		registered_elements[element] = tag
+
 		element
 	end
 
@@ -51,21 +50,23 @@ module Phlex::Elements
 		class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
 			# frozen_string_literal: true
 
-			def __phlex_#{element}__(**attributes)
+			def #{element}(**attributes)
+				target = @_context.target
+
 				if attributes.length > 0 # with attributes
-					@_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[respond_to?(:process_attributes) ? (attributes.hash + self.class.hash) : attributes.hash] || __attributes__(**attributes)) << ">"
+					target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[respond_to?(:process_attributes) ? (attributes.hash + self.class.hash) : attributes.hash] || __attributes__(**attributes)) << ">"
 				else # without attributes
-					@_target << "<#{tag}>"
+					target << "<#{tag}>"
 				end
 
 				nil
 			end
 
-			alias_method :_#{element}, :__phlex_#{element}__
-			alias_method :#{element}, :__phlex_#{element}__
-			private :__phlex_#{element}__
+			alias_method :_#{element}, :#{element}
 		RUBY
 
+		registered_elements[element] = tag
+
 		element
 	end
 end

data/lib/phlex/html.rb

@@ -25,7 +25,7 @@ module Phlex
 
 		# Output an HTML doctype.
 		def doctype
-			@_target << "<!DOCTYPE html>"
+			@_context.target << "<!DOCTYPE html>"
 			nil
 		end
 

data/lib/phlex/sgml.rb

@@ -12,8 +12,6 @@ module Phlex
 				new(...).call
 			end
 
-			alias_method :render, :call
-
 			# Create a new instance of the component.
 			# @note The block will not be delegated to the initializer. Instead, it will be provided to `template` when rendering.
 			def new(*args, **kwargs, &block)
@@ -31,28 +29,39 @@ module Phlex
 				alias_method :__attributes__, :__final_attributes__
 				alias_method :call, :__final_call__
 			end
+
+			# @api private
+			def element_method?(method_name)
+				return false unless instance_methods.include?(method_name)
+
+				owner = instance_method(method_name).owner
+
+				return true if owner.is_a?(Phlex::Elements) && owner.registered_elements[method_name]
+
+				false
+			end
 		end
 
 		# Renders the view and returns the buffer. The default buffer is a mutable String.
-		def call(buffer = nil, target: +"", view_context: nil, parent: nil, &block)
-			__final_call__(buffer, target: target, view_context: view_context, parent: parent, &block).tap do
+		def call(buffer = nil, context: Phlex::Context.new, view_context: nil, parent: nil, &block)
+			__final_call__(buffer, context: context, view_context: view_context, parent: parent, &block).tap do
 				self.class.rendered_at_least_once!
 			end
 		end
 
 		# @api private
-		def __final_call__(buffer = nil, target: +"", view_context: nil, parent: nil, &block)
-			@_target = target
+		def __final_call__(buffer = nil, context: Phlex::Context.new, view_context: nil, parent: nil, &block)
+			@_context = context
 			@_view_context = view_context
 			@_parent = parent
 
 			block ||= @_content_block
 
-			return buffer || target unless render?
+			return buffer || context.target unless render?
 
 			around_template do
 				if block
-					if DeferredRender === self
+					if is_a?(DeferredRender)
 						__vanish__(self, &block)
 						template
 					else
@@ -69,7 +78,7 @@ module Phlex
 				end
 			end
 
-			buffer ? (buffer << target) : target
+			buffer ? (buffer << context.target) : context.target
 		end
 
 		# Render another view
@@ -78,11 +87,15 @@ module Phlex
 		def render(renderable, &block)
 			case renderable
 			when Phlex::SGML
-				renderable.call(target: @_target, view_context: @_view_context, parent: self, &block)
+				renderable.call(context: @_context, view_context: @_view_context, parent: self, &block)
 			when Class
 				if renderable < Phlex::SGML
-					renderable.new.call(target: @_target, view_context: @_view_context, parent: self, &block)
+					renderable.new.call(context: @_context, view_context: @_view_context, parent: self, &block)
 				end
+			when Enumerable
+				renderable.each { |r| render(r, &block) }
+			when Proc
+				yield_content(&renderable)
 			else
 				raise ArgumentError, "You can't render a #{renderable}."
 			end
@@ -95,16 +108,16 @@ module Phlex
 		def plain(content)
 			case content
 			when String
-				@_target << ERB::Escape.html_escape(content)
+				@_context.target << ERB::Escape.html_escape(content)
 			when Symbol
-				@_target << ERB::Escape.html_escape(content.name)
+				@_context.target << ERB::Escape.html_escape(content.name)
 			when Integer
-				@_target << ERB::Escape.html_escape(content.to_s)
+				@_context.target << ERB::Escape.html_escape(content.to_s)
 			when nil
 				nil
 			else
 				if (formatted_object = format_object(content))
-					@_target << ERB::Escape.html_escape(formatted_object)
+					@_context.target << ERB::Escape.html_escape(formatted_object)
 				end
 			end
 
@@ -114,11 +127,13 @@ module Phlex
 		# Output a whitespace character. This is useful for getting inline elements to wrap. If you pass a block, a whitespace will be output before and after yielding the block.
 		# @return [nil]
 		def whitespace
-			@_target << " "
+			target = @_context.target
+
+			target << " "
 
 			if block_given?
 				yield
-				@_target << " "
+				target << " "
 			end
 
 			nil
@@ -127,9 +142,11 @@ module Phlex
 		# Output an HTML comment.
 		# @return [nil]
 		def comment(&block)
-			@_target << "<!-- "
+			target = @_context.target
+
+			target << "<!-- "
 			yield_content(&block)
-			@_target << " -->"
+			target << " -->"
 
 			nil
 		end
@@ -140,27 +157,17 @@ module Phlex
 		def unsafe_raw(content = nil)
 			return nil unless content
 
-			@_target << content
+			@_context.target << content
 			nil
 		end
 
 		# Capture a block of output as a String.
+		# @note This only works if the block's receiver is the current component or the block returns a String.
 		# @return [String]
 		def capture(&block)
-			return "" unless block_given?
+			return "" unless block
 
-			original_buffer_content = @_target.dup
-			@_target.clear
-
-			begin
-				yield_content(&block)
-				new_buffer_content = @_target.dup
-			ensure
-				@_target.clear
-				@_target << original_buffer_content
-			end
-
-			new_buffer_content.is_a?(String) ? new_buffer_content : ""
+			@_context.with_target(+"") { yield_content(&block) }
 		end
 
 		# Like `capture` but the output is vanished into a BlackHole buffer.
@@ -169,14 +176,7 @@ module Phlex
 		private def __vanish__(*args)
 			return unless block_given?
 
-			original_buffer = @_target
-
-			begin
-				@_target = BlackHole
-				yield(*args)
-			ensure
-				@_target = original_buffer
-			end
+			@_context.with_target(BlackHole) { yield(*args) }
 
 			nil
 		end
@@ -223,10 +223,11 @@ module Phlex
 		private def yield_content
 			return unless block_given?
 
-			original_length = @_target.length
-			content = yield(self)
+			target = @_context.target
 
-			plain(content) if original_length == @_target.length
+			original_length = target.length
+			content = yield(self)
+			plain(content) if original_length == target.length
 
 			nil
 		end
@@ -236,9 +237,11 @@ module Phlex
 		private def yield_content_with_args(*args)
 			return unless block_given?
 
-			original_length = @_target.length
+			target = @_context.target
+
+			original_length = target.length
 			content = yield(*args)
-			plain(content) if original_length == @_target.length
+			plain(content) if original_length == target.length
 
 			nil
 		end

data/lib/phlex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Phlex
-	VERSION = "1.5.1"
+	VERSION = "1.6.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phlex
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.1
 platform: ruby
 authors:
 - Joel Drapper
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-06 00:00:00.000000000 Z
+date: 2023-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -76,6 +76,7 @@ files:
 - lib/phlex.rb
 - lib/phlex/black_hole.rb
 - lib/phlex/callable.rb
+- lib/phlex/context.rb
 - lib/phlex/deferred_render.rb
 - lib/phlex/element_clobbering_guard.rb
 - lib/phlex/elements.rb