From 6abe53b91778608da9f6bfd9d202689fc5e57e62 Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Sat, 24 Oct 2015 23:39:34 +0900
Subject: [PATCH] Consistent naming for ChildrenCompiler

---
 lib/hamlit/compiler.rb                        |  6 +-
 lib/hamlit/compiler/children_compiler.rb      | 66 +++++++++++++++++++
 lib/hamlit/whitespace_compiler.rb             | 64 ------------------
 lib/pretty_hamlit/compiler.rb                 | 12 ++--
 .../compiler/children_compiler.rb             | 57 ++++++++++++++++
 lib/pretty_hamlit/whitespace_compiler.rb      | 55 ----------------
 6 files changed, 132 insertions(+), 128 deletions(-)
 create mode 100644 lib/hamlit/compiler/children_compiler.rb
 delete mode 100644 lib/hamlit/whitespace_compiler.rb
 create mode 100644 lib/pretty_hamlit/compiler/children_compiler.rb
 delete mode 100644 lib/pretty_hamlit/whitespace_compiler.rb

diff --git a/lib/hamlit/compiler.rb b/lib/hamlit/compiler.rb
index 5535da60..42997629 100644
--- a/lib/hamlit/compiler.rb
+++ b/lib/hamlit/compiler.rb
@@ -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)
diff --git a/lib/hamlit/compiler/children_compiler.rb b/lib/hamlit/compiler/children_compiler.rb
new file mode 100644
index 00000000..156f9f1e
--- /dev/null
+++ b/lib/hamlit/compiler/children_compiler.rb
@@ -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
diff --git a/lib/hamlit/whitespace_compiler.rb b/lib/hamlit/whitespace_compiler.rb
deleted file mode 100644
index 2138637a..00000000
--- a/lib/hamlit/whitespace_compiler.rb
+++ /dev/null
@@ -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
diff --git a/lib/pretty_hamlit/compiler.rb b/lib/pretty_hamlit/compiler.rb
index 464c2400..69a3503c 100644
--- a/lib/pretty_hamlit/compiler.rb
+++ b/lib/pretty_hamlit/compiler.rb
@@ -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)
diff --git a/lib/pretty_hamlit/compiler/children_compiler.rb b/lib/pretty_hamlit/compiler/children_compiler.rb
new file mode 100644
index 00000000..9c6c5b61
--- /dev/null
+++ b/lib/pretty_hamlit/compiler/children_compiler.rb
@@ -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
diff --git a/lib/pretty_hamlit/whitespace_compiler.rb b/lib/pretty_hamlit/whitespace_compiler.rb
deleted file mode 100644
index 4fed7e3e..00000000
--- a/lib/pretty_hamlit/whitespace_compiler.rb
+++ /dev/null
@@ -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