phlex 0.5.3 → 1.0.0.rc2

data/lib/phlex/compiler/formatter.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module Phlex
-	class Compiler
-		class Formatter < SyntaxTree::Formatter
-			def genspace
-				-> (n) { "\t" * (n / 2) }
-			end
-
-			def format(node, stackable: true)
-				stack << node if stackable
-				doc = node.format(self)
-				stack.pop if stackable
-				doc
-			end
-
-			def flush
-				text "" if @open_string_append
-
-				super
-			end
-
-			def breakable(*args, **kwargs)
-				if !@texting && @open_string_append
-					@broken = kwargs
-				else
-					super
-				end
-			end
-
-			def chain_append(&block)
-				@appending = true
-
-				if @open_string_append
-					text '" << '
-				elsif @open_chain_append
-					text " << "
-				else
-					text "@_target << "
-				end
-
-				@open_string_append = false
-				@open_chain_append = true
-
-				yield(self)
-
-				@appending = false
-			end
-
-			def append(&block)
-				@appending = true
-
-				unless @open_string_append
-					if @open_chain_append
-						text ' << "'
-					else
-						text '@_target << "'
-					end
-
-					@open_chain_append = false
-					@open_string_append = true
-				end
-
-				yield(self)
-
-				@appending = false
-			end
-
-			def text(value, ...)
-				@texting = true
-
-				unless @appending
-					if @open_string_append
-						super('"')
-						@open_string_append = false
-					end
-
-					@open_chain_append = false
-
-					breakable(**@broken) if @broken
-				end
-
-				@broken = false
-
-				super
-
-				@texting = false
-			end
-		end
-	end
-end

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

@@ -1,103 +0,0 @@
-# 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

@@ -1,61 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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

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

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

@@ -1,13 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-# 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

@@ -1,9 +0,0 @@
-# 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

@@ -1,66 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-# 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,29 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,28 +0,0 @@
-# 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

@@ -1,36 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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

@@ -1,59 +0,0 @@
-# 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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Phlex
-	class Compiler
-		def initialize(view)
-			@view = view
-		end
-
-		attr_writer :scope
-
-		def inspect
-			"#{self.class.name} for #{@view.name} view class"
-		end
-
-		def call
-			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::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 unscope
-			"; end" * @scope.size
-		end
-
-		def line
-			location[1]
-		end
-
-		private
-
-		def tree
-			@tree ||= SyntaxTree.parse(source)
-		end
-
-		def source
-			SyntaxTree.read(file)
-		end
-
-		def file
-			location[0]
-		end
-
-		def location
-			::Module.const_source_location(@view.name)
-		end
-	end
-end

data/lib/phlex/html/callbacks.rb

@@ -1,11 +0,0 @@
-# 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