phlex 0.3.2 → 0.5.0

data/lib/phlex/buffered.rb

@@ -1,19 +1,17 @@
 # frozen_string_literal: true
 
 module Phlex
-	class Buffered
+	class Buffered < SimpleDelegator
 		def initialize(object, buffer:)
-			@object, @buffer = object, buffer
+			super(object)
+			@buffer = buffer
 		end
 
-		def method_missing(name, *args, **kwargs, &block)
-			output = @object.public_send(name, *args, **kwargs, &block)
+		# Alias output methods to this
+		def __output_method__(*args, **kwargs, &block)
+			output = __getobj__.public_send(__callee__, *args, **kwargs, &block)
 			@buffer << output if output.is_a? String
 			nil
 		end
-
-		def respond_to_missing?(name)
-			@object.respond_to?(name)
-		end
 	end
 end

data/lib/phlex/callable.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Phlex
+	module Callable
+		def to_proc
+			method(:call).to_proc
+		end
+	end
+end

data/lib/phlex/collection.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Phlex
+	module Collection
+		def initialize(collection: nil, item: nil)
+			unless collection || item
+				raise ArgumentError, "You must pass a collection or an item as a keyword argument."
+			end
+
+			@collection = collection
+			@item = item
+		end
+
+		def template
+			@item ? item_template : collection_template { yield_items }
+		end
+
+		private
+
+		def yield_items
+			if @item
+				raise ArgumentError, "You can only yield_items when rendering a collection. You are currently rendering an item."
+			end
+
+			@collection.each do |item|
+				@item = item
+				item_template
+			end
+
+			@item = nil
+		end
+	end
+end

data/lib/phlex/compiler/elements.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Phlex::Compiler::Elements
+	module VCall
+		def format(formatter)
+			Phlex::Compiler::Generators::Element.new(
+				Phlex::Compiler::Nodes::VCall.new(self),
+				formatter: formatter
+			).call
+		end
+	end
+
+	module FCall
+		def format(formatter)
+			Phlex::Compiler::Generators::Element.new(
+				Phlex::Compiler::Nodes::FCall.new(self),
+				formatter: formatter
+			).call
+		end
+	end
+
+	module Command
+		def format(formatter)
+			Phlex::Compiler::Generators::Element.new(
+				Phlex::Compiler::Nodes::Command.new(self),
+				formatter: formatter
+			).call
+		end
+	end
+
+	module MutatingMethodAddBlock
+		def format(formatter)
+			Phlex::Compiler::Generators::Element.new(
+				Phlex::Compiler::Nodes::MethodAddBlock.new(self),
+				formatter: formatter,
+				mutating: true
+			).call
+		end
+	end
+
+	module MethodAddBlock
+		def format(formatter)
+			Phlex::Compiler::Generators::Element.new(
+				Phlex::Compiler::Nodes::MethodAddBlock.new(self),
+				formatter: formatter
+			).call
+		end
+	end
+end

data/lib/phlex/compiler/generators/content.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Phlex
+	class Compiler
+		module Generators
+			class Content
+				def initialize(formatter, content:, mutating: false)
+					@formatter = formatter
+					@content = content
+					@mutating = mutating
+				end
+
+				def call
+					return if nil_value?
+					return bare_string_value if bare_string_value?
+					return symbol_value if symbol_value?
+					return numeric_value if numeric_value?
+					return variable_value if variable_value?
+
+					unknown_value
+				end
+
+				private
+
+				def nil_value?
+					case @content
+					in SyntaxTree::VarRef[value: SyntaxTree::Kw[value: "nil"]]
+						true
+					else
+						false
+					end
+				end
+
+				def bare_string_value?
+					case @content
+					in SyntaxTree::StringLiteral[parts: [SyntaxTree::TStringContent]]
+						true
+					else
+						false
+					end
+				end
+
+				def symbol_value?
+					@content.is_a?(SyntaxTree::SymbolLiteral)
+				end
+
+				def numeric_value?
+					@content.is_a?(SyntaxTree::Int) || @content.is_a?(SyntaxTree::FloatLiteral)
+				end
+
+				def variable_value?
+					@content.is_a?(SyntaxTree::VarRef)
+				end
+
+				def bare_string_value
+					@formatter.append do |f|
+						f.text Hescape.escape_html(
+							@content.parts.first.value
+						)
+					end
+				end
+
+				def symbol_value
+					@formatter.append do |f|
+						f.text Hescape.escape_html(
+							@content.value.value
+						)
+					end
+				end
+
+				def numeric_value
+					@formatter.append do |f|
+						f.text Hescape.escape_html(
+							@content.value
+						)
+					end
+				end
+
+				def variable_value
+					@formatter.chain_append do |f|
+						f.text "Hescape.escape_html("
+						@content.format(f)
+						f.text ")"
+					end
+				end
+
+				def unknown_value
+					@formatter.breakable(force: true)
+					if @mutating
+						@content.format(@formatter)
+					else
+						@formatter.text "yield_content {"
+						@formatter.breakable(force: true)
+						@content.format(@formatter)
+						@formatter.breakable(force: true)
+						@formatter.text "}"
+					end
+					@formatter.breakable(force: true)
+				end
+			end
+		end
+	end
+end

data/lib/phlex/compiler/generators/element.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Phlex
+	class Compiler
+		module Generators
+			class Element
+				def initialize(node, formatter:, mutating: false)
+					@node = node
+					@formatter = formatter
+					@mutating = mutating
+				end
+
+				def call
+					@formatter.append do |f|
+						f.text "<"
+						f.text tag
+					end
+
+					if @node.arguments&.parts&.any?
+						@formatter.chain_append do |f|
+							f.text "_attributes("
+							@node.arguments.format(@formatter)
+							f.text ")"
+						end
+					end
+
+					@formatter.append do |f|
+						f.text ">"
+					end
+
+					return if void?
+
+					case @node.content
+					in SyntaxTree::Statements[body: [c]]
+						Content.new(@formatter, content: c, mutating: @mutating).call
+					in nil
+						nil
+					else
+						@node.content.format(@formatter)
+					end
+
+					@formatter.append do |f|
+						f.text "</"
+						f.text tag
+						f.text ">"
+					end
+				end
+
+				private
+
+				def tag
+					HTML::STANDARD_ELEMENTS[@node.name] || HTML::VOID_ELEMENTS[@node.name]
+				end
+
+				def void?
+					HTML::VOID_ELEMENTS.key?(@node.name)
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Phlex::Compiler::Nodes
+	class Base
+		def initialize(node)
+			@node = node
+		end
+
+		attr_accessor :node
+
+		def arguments
+			nil
+		end
+
+		def content
+			nil
+		end
+	end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Phlex::Compiler::Nodes
+	class Call < Base
+		def name
+			nil
+		end
+	end
+end

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