phlex 0.4.0 → 0.5.1

data/lib/phlex/compiler/nodes/command.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Phlex::Compiler::Nodes
+	class Command < Base
+		def name
+			@node.message.value.to_sym
+		end
+
+		def arguments
+			@node.arguments
+		end
+	end
+end

data/lib/phlex/compiler/nodes/fcall.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Phlex::Compiler::Nodes
+	class FCall < Base
+		def name
+			@node.value.value.to_sym
+		end
+
+		def arguments
+			case @node.arguments
+			in SyntaxTree::Args
+				@node.arguments
+			in SyntaxTree::ArgParen
+				@node.arguments.arguments
+			end
+		end
+	end
+end

data/lib/phlex/compiler/nodes/method_add_block.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Phlex::Compiler::Nodes
+	class MethodAddBlock < Base
+		def name
+			method_call.name
+		end
+
+		def arguments
+			method_call.arguments
+		end
+
+		def method_call
+			@method_call ||= case @node.call
+			in SyntaxTree::FCall
+				Phlex::Compiler::Nodes::FCall.new(@node.call)
+			in SyntaxTree::Command
+				Phlex::Compiler::Nodes::Command.new(@node.call)
+			in SyntaxTree::Call
+				Phlex::Compiler::Nodes::Call.new(@node.call)
+			end
+		end
+
+		def content
+			case @node.block
+			in SyntaxTree::BraceBlock
+				@node.block.statements
+			in SyntaxTree::DoBlock
+				@node.block.bodystmt.statements
+			end
+		end
+	end
+end

data/lib/phlex/compiler/nodes/vcall.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Phlex::Compiler::Nodes
+	class VCall < Base
+		def name
+			@node.value.value.to_sym
+		end
+	end
+end

data/lib/phlex/compiler/optimizer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class Phlex::Compiler
+	class Optimizer
+		def initialize(node, compiler:)
+			@node = node
+			@compiler = compiler
+		end
+
+		def call
+			return optimize_element if optimize_element?
+
+			false
+		end
+
+		private
+
+		def optimize_element
+			case @node
+			in Nodes::VCall
+				@node.node.extend(Phlex::Compiler::Elements::VCall)
+			in Nodes::FCall
+				@node.node.extend(Phlex::Compiler::Elements::FCall)
+			in Nodes::Command
+				@node.node.extend(Phlex::Compiler::Elements::Command)
+			in Nodes::MethodAddBlock
+				optimize_add_method_block_element
+			end
+
+			true
+		end
+
+		def optimize_add_method_block_element
+			visitor = Phlex::Compiler::Visitors::Statements.new(@compiler)
+			visitor.visit(@node.content)
+
+			if visitor.mutating?
+				@node.node.extend(Phlex::Compiler::Elements::MutatingMethodAddBlock)
+			else
+				@node.node.extend(Phlex::Compiler::Elements::MethodAddBlock)
+			end
+
+			Phlex::Compiler::Visitors::ViewMethod.new(@compiler).visit(@node.content)
+		end
+
+		def optimize_element?
+			element? && !redefined?
+		end
+
+		def element?
+			standard_element? || void_element?
+		end
+
+		def redefined?
+			@compiler.redefined?(@node.name)
+		end
+
+		def standard_element?
+			Phlex::HTML::STANDARD_ELEMENTS.key?(@node.name)
+		end
+
+		def void_element?
+			Phlex::HTML::VOID_ELEMENTS.key?(@node.name)
+		end
+	end
+end

data/lib/phlex/compiler/visitors/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Phlex::Compiler::Visitors
+	class Base < SyntaxTree::Visitor
+		def initialize(compiler = nil)
+			@compiler = compiler
+		end
+
+		private
+
+		def format(node)
+			Phlex::Compiler::Formatter.format("", node)
+		end
+	end
+end

data/lib/phlex/compiler/visitors/file.rb

@@ -1,17 +1,29 @@
 # frozen_string_literal: true
 
-module Phlex
-	class Compiler
-		module Visitors
-			class File < BaseVisitor
-				visit_method def visit_class(node)
-					if node.location.start_line == @compiler.line
-						Visitors::Component.new(@compiler).visit_all(node.child_nodes)
-					else
-						super
-					end
-				end
+module Phlex::Compiler::Visitors
+	class File < Base
+		def initialize(compiler)
+			@scope = []
+			super
+		end
+
+		visit_method def visit_class(node)
+			@scope.push(node)
+
+			if node.location.start_line == @compiler.line
+				@compiler.scope = @scope
+				View.new(@compiler).visit_all(node.child_nodes)
+			else
+				super
 			end
+
+			@scope.pop
+		end
+
+		visit_method def visit_module(node)
+			@scope.push(node)
+			super
+			@scope.pop
 		end
 	end
 end

data/lib/phlex/compiler/visitors/stable_scope.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# A mixin for visitors that stops them from visiting other scopes.
+
+module Phlex::Compiler::Visitors::StableScope
+	def visit_class(node)
+		nil
+	end
+
+	def visit_module(node)
+		nil
+	end
+
+	def visit_brace_block(node)
+		nil
+	end
+
+	def visit_do_block(node)
+		nil
+	end
+
+	def visit_method_add_block(node)
+		node = Phlex::Compiler::Nodes::MethodAddBlock.new(node)
+		if node.method_call.name == :render
+			visit(node.content)
+		end
+	end
+end

data/lib/phlex/compiler/visitors/statements.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Phlex::Compiler::Visitors
+	class Statements < Base
+		MUTATING_METHODS = [:raw, :whitespace, :comment, :text, :doctype]
+
+		include StableScope
+
+		def mutating?
+			!!@mutating
+		end
+
+		visit_method def visit_vcall(node)
+			check Phlex::Compiler::Nodes::VCall.new(node)
+		end
+
+		visit_method def visit_fcall(node)
+			check Phlex::Compiler::Nodes::FCall.new(node)
+		end
+
+		visit_method def visit_command(node)
+			check Phlex::Compiler::Nodes::Command.new(node)
+		end
+
+		visit_method def visit_method_add_block(node)
+			check Phlex::Compiler::Nodes::MethodAddBlock.new(node)
+		end
+
+		private
+
+		def check(node)
+			@mutating = true if @compiler.tag_method?(node.name)
+			@mutating = true if MUTATING_METHODS.include?(node.name) && !@compiler.redefined?(node.name)
+		end
+	end
+end

data/lib/phlex/compiler/visitors/view.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Phlex::Compiler::Visitors
+	class View < Base
+		include StableScope
+
+		visit_method def visit_def(node)
+			visitor = ViewMethod.new(@compiler)
+			visitor.visit_all(node.child_nodes)
+
+			if visitor.optimized_something?
+				@compiler.redefine(
+					format(node),
+					line: node.location.start_line
+				)
+			end
+		end
+	end
+end

data/lib/phlex/compiler/visitors/view_method.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Phlex::Compiler::Visitors
+	class ViewMethod < Base
+		include StableScope
+
+		def optimized_something?
+			!!@optimized_something
+		end
+
+		visit_method def visit_method_add_block(node)
+			return super if node.call.is_a?(SyntaxTree::Call)
+
+			optimizer = Phlex::Compiler::Optimizer.new(
+				Phlex::Compiler::Nodes::MethodAddBlock.new(node),
+				compiler: @compiler
+			)
+
+			if optimizer.call
+				@optimized_something = true
+			end
+
+			super
+		end
+
+		visit_method def visit_vcall(node)
+			optimizer = Phlex::Compiler::Optimizer.new(
+				Phlex::Compiler::Nodes::VCall.new(node),
+				compiler: @compiler
+			)
+
+			if optimizer.call
+				@optimized_something = true
+			end
+		end
+
+		visit_method def visit_fcall(node)
+			optimizer = Phlex::Compiler::Optimizer.new(
+				Phlex::Compiler::Nodes::FCall.new(node),
+				compiler: @compiler
+			)
+
+			if optimizer.call
+				@optimized_something = true
+			end
+		end
+
+		visit_method def visit_command(node)
+			optimizer = Phlex::Compiler::Optimizer.new(
+				Phlex::Compiler::Nodes::Command.new(node),
+				compiler: @compiler
+			)
+
+			if optimizer.call
+				@optimized_something = true
+			end
+		end
+	end
+end

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/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