phlex 0.3.2 → 0.5.0

data/lib/phlex/compiler.rb

@@ -6,6 +6,8 @@ module Phlex
 			@view = view
 		end
 
+		attr_writer :scope
+
 		def inspect
 			"#{self.class.name} for #{@view.name} view class"
 		end
@@ -14,15 +16,33 @@ module Phlex
 			Visitors::File.new(self).visit(tree)
 		end
 
+		def tag_method?(method_name)
+			(HTML::STANDARD_ELEMENTS.key?(method_name) || HTML::VOID_ELEMENTS.key?(method_name)) && !redefined?(method_name)
+		end
+
 		def redefined?(method_name)
 			prototype = @view.allocate
 
 			@view.instance_method(method_name).bind(prototype) !=
-				Phlex::View.instance_method(method_name).bind(prototype)
+				Phlex::HTML.instance_method(method_name).bind(prototype)
+		end
+
+		def redefine(method, line:)
+			patch = scope + method + unscope
+			eval(patch, Kernel.binding, file, (line - 1))
+		end
+
+		def scope
+			@scope.map do |scope|
+				case scope
+					in SyntaxTree::ModuleDeclaration then "module #{scope.constant.constant.value};"
+					in SyntaxTree::ClassDeclaration then "class #{scope.constant.constant.value};"
+				end
+			end.join + "\n"
 		end
 
-		def redefine(method)
-			@view.class_eval(method)
+		def unscope
+			"; end" * @scope.size
 		end
 
 		def line

data/lib/phlex/elements.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.0")
+	using Overrides::Symbol::Name
+end
+
+module Phlex
+	module Elements
+		def register_element(element, tag: element.name.tr("_", "-"))
+			class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        # frozen_string_literal: true
+
+        def #{element}(content = nil, **attributes, &block)
+					if content
+						raise ArgumentError, %(👋 You can no longer pass content to #{element} as a positional argument.\n Instead, you can pass it as a block, e.g. #{element} { "Hello" })
+					end
+
+          if attributes.length > 0
+            if block_given?
+              @_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes.hash] || _attributes(**attributes)) << ">"
+              yield_content(&block)
+              @_target << "</#{tag}>"
+            else
+              @_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes.hash] || _attributes(**attributes)) << "></#{tag}>"
+            end
+          else
+            if block_given?
+              @_target << "<#{tag}>"
+              yield_content(&block)
+              @_target << "</#{tag}>"
+            else
+              @_target << "<#{tag}></#{tag}>"
+            end
+          end
+
+          nil
+        end
+			RUBY
+		end
+
+		def register_void_element(element, tag: element.name.tr("_", "-"))
+			class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        # frozen_string_literal: true
+
+        def #{element}(**attributes)
+          if attributes.length > 0
+            @_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes.hash] || _attributes(**attributes)) << ">"
+          else
+            @_target << "<#{tag}>"
+          end
+
+          nil
+        end
+			RUBY
+		end
+	end
+end

data/lib/phlex/engine.rb

@@ -4,8 +4,5 @@ require "rails/engine"
 
 module Phlex
 	class Engine < ::Rails::Engine
-		initializer "phlex.tag_helpers" do
-			Phlex::View.include(Phlex::Rails::TagHelpers)
-		end
 	end
 end

data/lib/phlex/helpers.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.0")
+	using Overrides::Symbol::Name
+end
+
+module Phlex::Helpers
+	def tokens(*tokens, **conditional_tokens)
+		conditional_tokens.each do |condition, token|
+			case condition
+			when Symbol then next unless send(condition)
+			when Proc then next unless condition.call
+			else raise ArgumentError,
+				"The class condition must be a Symbol or a Proc."
+			end
+
+			case token
+			when Symbol then tokens << token.name
+			when String then tokens << token
+			when Array then tokens.concat(token)
+			else raise ArgumentError,
+				"Conditional classes must be Symbols, Strings, or Arrays of Symbols or Strings."
+			end
+		end
+
+		tokens.compact.join(" ")
+	end
+
+	def classes(*tokens, **conditional_tokens)
+		tokens = self.tokens(*tokens, **conditional_tokens)
+
+		if tokens.empty?
+			{}
+		else
+			{ class: tokens }
+		end
+	end
+
+	def mix(*args)
+		args.each_with_object({}) do |object, result|
+			result.merge!(object) do |_key, old, new|
+				case new
+				when Hash
+					old.is_a?(Hash) ? mix(old, new) : new
+				when Array
+					old.is_a?(Array) ? (old + new) : new
+				when String
+					old.is_a?(String) ? "#{old} #{new}" : new
+				else
+					new
+				end
+			end
+
+			result.transform_keys! do |key|
+				key.end_with?("!") ? key.name.chop.to_sym : key
+			end
+		end
+	end
+end

data/lib/phlex/html/callbacks.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Phlex::HTML::Callbacks
+	def template(&block)
+		before_rendering_template if respond_to?(:before_rendering_template)
+
+		super
+
+		after_rendering_template if respond_to?(:after_rendering_template)
+	end
+end

data/lib/phlex/html.rb

@@ -5,7 +5,7 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.0")
 end
 
 module Phlex
-	module HTML
+	class HTML
 		DOCTYPE = "<!DOCTYPE html>"
 
 		STANDARD_ELEMENTS = {
@@ -113,6 +113,7 @@ module Phlex
 			area: "area",
 			br: "br",
 			embed: "embed",
+			hr: "hr",
 			img: "img",
 			input: "input",
 			link: "link",
@@ -125,59 +126,213 @@ module Phlex
 
 		EVENT_ATTRIBUTES = %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 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].to_h { [_1, true] }.freeze
 
-		def register_element(element, tag: element.name.tr("_", "-"))
-			class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        # frozen_string_literal: true
-
-        def #{element}(content = nil, **attributes, &block)
-          if attributes.length > 0
-            if content
-              @_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes.hash] || _attributes(attributes)) << ">" << CGI.escape_html(content) << "</#{tag}>"
-            elsif block_given?
-              @_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes.hash] || _attributes(attributes)) << ">"
-              yield_content(&block)
-              @_target << "</#{tag}>"
-            else
-              @_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes.hash] || _attributes(attributes)) << "></#{tag}>"
-            end
-          else
-            if content
-              case content
-              when String
-                @_target << "<#{tag}>" << CGI.escape_html(content) << "</#{tag}>"
-              when Symbol
-                @_target << "<#{tag}>" << CGI.escape_html(content.name) << "</#{tag}>"
-              else
-                @_target << "<#{tag}>" << CGI.escape_html(content.to_s) << "</#{tag}>"
-              end
-            elsif block_given?
-              @_target << "<#{tag}>"
-              yield_content(&block)
-              @_target << "</#{tag}>"
-            else
-              @_target << "<#{tag}></#{tag}>"
-            end
-          end
-
-          nil
-        end
-			RUBY
-		end
-
-		def register_void_element(element, tag: element.name.tr("_", "-"))
-			class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        # frozen_string_literal: true
-
-        def #{element}(**attributes)
-          if attributes.length > 0
-            @_target << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes.hash] || _attributes(attributes)) << " />"
-          else
-            @_target << "<#{tag} />"
-          end
-
-          nil
-        end
-			RUBY
+		extend Elements
+		include Helpers
+		include Callable
+		include Renderable
+
+		class << self
+			attr_accessor :rendered_at_least_once
+
+			# 			def compile
+			# 				return if @compiled
+			# 				return unless name
+			# 				return if name.start_with? "#"
+			#
+			# 				Compiler.new(self).call
+			#
+			# 				@compiled = true
+			# 			end
+			#
+			# 			def compiled?
+			# 				!!@compiled
+			# 			end
+		end
+
+		def call(buffer = +"", view_context: nil, parent: nil, &block)
+			return buffer unless render?
+
+			raise "The same view instance shouldn't be rendered twice" if rendered?
+
+			@_rendered = true
+			@_target = buffer
+			@_view_context = view_context
+			@_parent = parent
+			@output_buffer = self
+
+			template(&block)
+
+			self.class.rendered_at_least_once ||= true
+
+			buffer
+		end
+
+		def rendered?
+			@_rendered ||= false
+		end
+
+		def render?
+			true
+		end
+
+		STANDARD_ELEMENTS.each do |method_name, tag|
+			register_element(method_name, tag: tag)
+		end
+
+		VOID_ELEMENTS.each do |method_name, tag|
+			register_void_element(method_name, tag: tag)
+		end
+
+		def yield_content(&block)
+			return unless block_given?
+
+			original_length = @_target.length
+			output = yield(self)
+			unchanged = (original_length == @_target.length)
+
+			if unchanged
+				case output
+				when String, Symbol, Integer, Float
+					text(output)
+				end
+			end
+
+			nil
+		end
+
+		def text(content)
+			@_target << _output(content)
+
+			nil
+		end
+
+		def _output(content)
+			case content
+			when String then Hescape.escape_html(content)
+			when Symbol then Hescape.escape_html(content.name)
+			else Hescape.escape_html(content.to_s)
+			end
+		end
+
+		def whitespace
+			@_target << " "
+
+			if block_given?
+				yield
+				@_target << " "
+			end
+
+			nil
+		end
+
+		def comment(content = "")
+			@_target << "<!-- " << Hescape.escape_html(content.to_s) << " -->"
+			nil
+		end
+
+		def doctype
+			@_target << DOCTYPE
+			nil
+		end
+
+		def unsafe_raw(content = nil, &block)
+			@_target << (content || instance_exec(&block))
+			nil
+		end
+
+		def html_safe?
+			true
+		end
+
+		def safe_append=(value)
+			return unless value
+
+			@_target << case value
+			when String then value
+			when Symbol then value.name
+			else value.to_s
+			end
+		end
+
+		def append=(value)
+			return unless value
+
+			if value.html_safe?
+				self.safe_append = value
+			else
+				@_target << case value
+				when String then Hescape.escape_html(value)
+				when Symbol then Hescape.escape_html(value.name)
+				else Hescape.escape_html(value.to_s)
+				end
+			end
+		end
+
+		def capture(&block)
+			return unless block_given?
+
+			original_buffer = @_target
+			new_buffer = +""
+			@_target = new_buffer
+
+			yield
+
+			@_target = original_buffer
+
+			new_buffer.html_safe
+		end
+
+		def helpers
+			@_view_context
+		end
+
+		def _attributes(**attributes)
+			if attributes[:href]&.start_with?(/\s*javascript/)
+				attributes[:href] = attributes[:href].sub(/^\s*(javascript:)+/, "")
+			end
+
+			buffer = +""
+			_build_attributes(attributes, buffer: buffer)
+
+			unless self.class.rendered_at_least_once
+				Phlex::ATTRIBUTE_CACHE[attributes.hash] = buffer.freeze
+			end
+
+			buffer
+		end
+
+		def _build_attributes(attributes, buffer:)
+			attributes.each do |k, v|
+				next unless v
+
+				name = case k
+				when String
+					k
+				when Symbol
+					k.name.tr("_", "-")
+				else
+					k.to_s
+				end
+
+				if HTML::EVENT_ATTRIBUTES[name] || name.match?(/[<>&"']/)
+					raise ArgumentError, "Unsafe attribute name detected: #{k}."
+				end
+
+				case v
+				when true
+					buffer << " " << name
+				when String
+					buffer << " " << name << '="' << Hescape.escape_html(v) << '"'
+				when Symbol
+					buffer << " " << name << '="' << Hescape.escape_html(v.name) << '"'
+				when Hash
+					_build_attributes(v.transform_keys { "#{k}-#{_1.name.tr('_', '-')}" }, buffer: buffer)
+				else
+					buffer << " " << name << '="' << Hescape.escape_html(v.to_s) << '"'
+				end
+			end
+
+			buffer
 		end
 	end
 end

data/lib/phlex/markdown.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "commonmarker"
+
+module Phlex
+	class Markdown < Phlex::HTML
+		def initialize(content)
+			@content = content
+		end
+
+		def template
+			visit(doc)
+		end
+
+		private
+
+		def doc
+			CommonMarker.render_doc(@content)
+		end
+
+		def visit(node)
+			return if node.nil?
+
+			case node.type
+			in :document | :softbreak
+				visit_children(node)
+			in :text
+				text(node.string_content)
+			in :header
+				case node.header_level
+					in 1 then h1 { visit_children(node) }
+					in 2 then h2 { visit_children(node) }
+					in 3 then h3 { visit_children(node) }
+					in 4 then h4 { visit_children(node) }
+					in 5 then h5 { visit_children(node) }
+					in 6 then h6 { visit_children(node) }
+				end
+			in :paragraph
+				grandparent = node.parent&.parent
+
+				if grandparent&.type == :list && grandparent&.list_tight
+					visit_children(node)
+				else
+					p { visit_children(node) }
+				end
+			in :link
+				a(href: node.url) { visit_children(node) }
+			in :emph
+				em { visit_children(node) }
+			in :strong
+				strong { visit_children(node) }
+			in :list
+				case node.list_type
+					in :ordered_list then ol { visit_children(node) }
+					in :bullet_list then ul { visit_children(node) }
+				end
+			in :list_item
+				li { visit_children(node) }
+			in :code
+				whitespace { code { text(node.string_content) } }
+			in :code_block
+				code_block(node.string_content, language: node.fence_info) do |**attributes|
+					pre(**attributes) { text(node.string_content) }
+				end
+			end
+		end
+
+		def code_block(code, language:)
+			yield
+		end
+
+		def visit_children(node)
+			node.each { |c| visit(c) }
+		end
+	end
+end

data/lib/phlex/rails/form.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Phlex
+	module Rails
+		class Form < Phlex::HTML
+			def initialize(model)
+				@model = model
+			end
+
+			def self.input_field(method_name, type:)
+				define_method method_name do |field, value: @model.attributes[field.to_s], **attributes|
+					input(
+						name: field_name(field),
+						type: type,
+						value: value,
+						**attributes
+					)
+				end
+			end
+
+			def template(&block)
+				form action: @url, method: @method do
+					authenticity_token_field
+					yield_content(&block)
+				end
+			end
+
+			def authenticity_token_field
+				input(
+					name: "authenticity_token",
+					type: "hidden",
+					value: @_view_context.form_authenticity_token
+				)
+			end
+
+			def submit(value)
+				input(
+					name: "commit",
+					type: "submit",
+					value: value
+				)
+			end
+
+			def url
+				@_view_context.url_for(@model)
+			end
+
+			def field_name(*field)
+				@_view_context.field_name(ActiveModel::Naming.param_key(@model.class), *field)
+			end
+
+			input_field :url_field, type: "url"
+			input_field :text_field, type: "text"
+			input_field :date_field, type: "date"
+			input_field :time_field, type: "time"
+			input_field :week_field, type: "week"
+			input_field :month_field, type: "month"
+			input_field :email_field, type: "email"
+			input_field :color_field, type: "color"
+			input_field :hidden_field, type: "hidden"
+			input_field :search_field, type: "search"
+			input_field :password_field, type: "password"
+			input_field :telephone_field, type: "tel"
+			input_field :datetime_local_field, type: "datetime-local"
+		end
+	end
+end