kotovalexarian-likes-github
/
haml--haml
mirror of https://github.com/haml/haml.git
1
0
Fork 0
Code Releases Activity

Consistent naming for ChildrenCompiler

This commit is contained in:
Takashi Kokubun 2015-10-24 23:39:34 +09:00
parent 0070620624
commit 6abe53b917
6 changed files with 132 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
lib/hamlit/compiler.rb
View File

@ -1,14 +1,15 @@
require 'hamlit/compiler/children_compiler'
require 'hamlit/compiler/comment_compiler'
require 'hamlit/compiler/doctype_compiler'
require 'hamlit/compiler/script_compiler'
require 'hamlit/compiler/silent_script_compiler'
require 'hamlit/compiler/tag_compiler'
require 'hamlit/filters'
require 'hamlit/whitespace_compiler'
module Hamlit
class Compiler
def initialize(options = {})
@children_compiler = ChildrenCompiler.new
@comment_compiler = CommentCompiler.new
@doctype_compiler = DoctypeCompiler.new(options)
@script_compiler = ScriptCompiler.new
@ -16,7 +17,6 @@ module Hamlit
@tag_compiler = TagCompiler.new(options)
@filter_compiler = Filters.new(options)
@whitespace_compiler = WhitespaceCompiler.new
end
def call(ast)
@ -51,7 +51,7 @@ module Hamlit
end
def compile_children(node)
@whitespace_compiler.compile_children(node) { |n| compile(n) }
@children_compiler.compile(node) { |n| compile(n) }
end
def compile_comment(node)

66
lib/hamlit/compiler/children_compiler.rb Normal file
View File

@ -0,0 +1,66 @@
module Hamlit
class Compiler
class ChildrenCompiler
def compile(node, &block)
temple = [:multi]
return temple if node.children.empty?
temple << :whitespace if prepend_whitespace?(node)
node.children.each do |n|
rstrip_whitespace!(temple) if nuke_outer_whitespace?(n)
temple << yield(n)
temple << :whitespace if insert_whitespace?(n)
end
rstrip_whitespace!(temple) if nuke_inner_whitespace?(node)
confirm_whitespace(temple)
end
private
def confirm_whitespace(temple)
temple.map do |exp|
case exp
when :whitespace
[:static, "\n"]
else
exp
end
end
end
def prepend_whitespace?(node)
return false unless %i[comment tag].include?(node.type)
!nuke_inner_whitespace?(node)
end
def nuke_inner_whitespace?(node)
return false if node.type != :tag
node.value[:nuke_inner_whitespace]
end
def nuke_outer_whitespace?(node)
return false if node.type != :tag
node.value[:nuke_outer_whitespace]
end
def rstrip_whitespace!(temple)
if temple[-1] == :whitespace
temple.delete_at(-1)
end
end
def insert_whitespace?(node)
return false if nuke_outer_whitespace?(node)
case node.type
when :doctype
node.value[:type] != 'xml'
when :comment, :filter, :plain, :script, :tag
true
else
false
end
end
end
end
end

64
lib/hamlit/whitespace_compiler.rb
View File

@ -1,64 +0,0 @@
module Hamlit
class WhitespaceCompiler
def compile_children(node, &block)
temple = [:multi]
return temple if node.children.empty?
temple << :whitespace if prepend_whitespace?(node)
node.children.each do |n|
rstrip_whitespace!(temple) if nuke_outer_whitespace?(n)
temple << yield(n)
temple << :whitespace if insert_whitespace?(n)
end
rstrip_whitespace!(temple) if nuke_inner_whitespace?(node)
confirm_whitespace(temple)
end
private
def confirm_whitespace(temple)
temple.map do |exp|
case exp
when :whitespace
[:static, "\n"]
else
exp
end
end
end
def prepend_whitespace?(node)
return false unless %i[comment tag].include?(node.type)
!nuke_inner_whitespace?(node)
end
def nuke_inner_whitespace?(node)
return false if node.type != :tag
node.value[:nuke_inner_whitespace]
end
def nuke_outer_whitespace?(node)
return false if node.type != :tag
node.value[:nuke_outer_whitespace]
end
def rstrip_whitespace!(temple)
if temple[-1] == :whitespace
temple.delete_at(-1)
end
end
def insert_whitespace?(node)
return false if nuke_outer_whitespace?(node)
case node.type
when :doctype
node.value[:type] != 'xml'
when :comment, :filter, :plain, :script, :tag
true
else
false
end
end
end
end

12
lib/pretty_hamlit/compiler.rb
View File

@ -1,23 +1,23 @@
require 'hamlit/compiler'
require 'pretty_hamlit/compiler/children_compiler'
require 'pretty_hamlit/compiler/tag_compiler'
require 'pretty_hamlit/filters'
require 'pretty_hamlit/whitespace_compiler'
module PrettyHamlit
class Compiler < Hamlit::Compiler
def initialize(options = {})
super
@indent_level = 0
@tag_compiler = TagCompiler.new(options)
@filter_compiler = Filters.new(options)
@whitespace_compiler = WhitespaceCompiler.new
@children_compiler = ChildrenCompiler.new
@tag_compiler = TagCompiler.new(options)
@filter_compiler = Filters.new(options)
end
private
def compile_children(node)
@whitespace_compiler.compile_children(node, @indent_level) { |n| compile(n) }
@children_compiler.compile(node, @indent_level) { |n| compile(n) }
end
def compile_comment(node)

57
lib/pretty_hamlit/compiler/children_compiler.rb Normal file
View File

@ -0,0 +1,57 @@
require 'hamlit/compiler/children_compiler'
module PrettyHamlit
class Compiler < Hamlit::Compiler
class ChildrenCompiler < Hamlit::Compiler::ChildrenCompiler
def compile(node, indent_level, &block)
temple = [:multi]
return temple if node.children.empty?
temple << :whitespace if prepend_whitespace?(node)
node.children.each do |n|
rstrip_whitespace!(temple) if nuke_outer_whitespace?(n)
temple << yield(n)
if insert_whitespace?(n)
if nuke_inner_whitespace?(node)
temple << :weak_whitespace
else
temple << :whitespace
end
end
end
rstrip_whitespace!(temple) if nuke_inner_whitespace?(node)
weaken_last_whitespace!(temple)
confirm_whitespace(temple, indent_level)
end
private
def rstrip_whitespace!(temple)
if %i[whitespace weak_whitespace].include?(temple[-1])
temple.delete_at(-1)
end
end
def weaken_last_whitespace!(temple)
if temple[-1] == :whitespace
temple.delete_at(-1)
temple << :weak_whitespace
end
end
def confirm_whitespace(temple, indent_level)
temple.map do |exp|
case exp
when :whitespace
[:static, "\n" + (' ' * indent_level)]
when :weak_whitespace
level = [0, indent_level - 1].max
[:static, "\n" + (' ' * level)]
else
exp
end
end
end
end
end
end

55
lib/pretty_hamlit/whitespace_compiler.rb
View File

@ -1,55 +0,0 @@
require 'hamlit/whitespace_compiler'
module PrettyHamlit
class WhitespaceCompiler < Hamlit::WhitespaceCompiler
def compile_children(node, indent_level, &block)
temple = [:multi]
return temple if node.children.empty?
temple << :whitespace if prepend_whitespace?(node)
node.children.each do |n|
rstrip_whitespace!(temple) if nuke_outer_whitespace?(n)
temple << yield(n)
if insert_whitespace?(n)
if nuke_inner_whitespace?(node)
temple << :weak_whitespace
else
temple << :whitespace
end
end
end
rstrip_whitespace!(temple) if nuke_inner_whitespace?(node)
weaken_last_whitespace!(temple)
confirm_whitespace(temple, indent_level)
end
private
def rstrip_whitespace!(temple)
if %i[whitespace weak_whitespace].include?(temple[-1])
temple.delete_at(-1)
end
end
def weaken_last_whitespace!(temple)
if temple[-1] == :whitespace
temple.delete_at(-1)
temple << :weak_whitespace
end
end
def confirm_whitespace(temple, indent_level)
temple.map do |exp|
case exp
when :whitespace
[:static, "\n" + (' ' * indent_level)]
when :weak_whitespace
level = [0, indent_level - 1].max
[:static, "\n" + (' ' * level)]
else
exp
end
end
end
end
end