syntax_tree-haml 1.0.1 → 1.2.1

data/lib/syntax_tree/haml/pretty_print.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module Haml
+    class PrettyPrint < Visitor
+      attr_reader :q
+
+      def initialize(q)
+        @q = q
+      end
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#html-comments-
+      def visit_comment(node)
+        group("comment") do
+          if node.value[:conditional]
+            pp_field("conditional", node.value[:conditional])
+          elsif node.value[:text]
+            pp_field("text", node.value[:text])
+          end
+
+          bool_field("revealed") if node.value[:revealed]
+          pp_field("children", node.children) if node.children.any?
+        end
+      end
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#doctype-
+      def visit_doctype(node)
+        group("doctype") do
+          if DOCTYPE_TYPES.key?(node.value[:type])
+            pp_field("type", node.value[:type])
+          elsif DOCTYPE_VERSIONS.include?(node.value[:version])
+            pp_field("version", node.value[:version])
+          else
+            pp_field("text", node.value[:text])
+          end
+
+          pp_field("encoding", node.value[:encoding]) if node.value[:encoding]
+        end
+      end
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#filter
+      def visit_filter(node)
+        group("filter") do
+          text_field("name", node.value[:name])
+          pp_field("text", node.value[:text])
+        end
+      end
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#haml-comments--
+      def visit_haml_comment(node)
+        group("haml_comment") { pp_field("text", node.value[:text]) }
+      end
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#plain-text
+      def visit_plain(node)
+        group("plain") { pp_field("text", node.value[:text]) }
+      end
+
+      # Visit the root node of the AST.
+      def visit_root(node)
+        group("root") do
+          pp_field("children", node.children) if node.children.any?
+        end
+      end
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#inserting_ruby
+      def visit_script(node)
+        group("script") do
+          pp_field("text", node.value[:text])
+          bool_field("escape_html") if node.value[:escape_html]
+          bool_field("preserve") if node.value[:preserve]
+          pp_field("children", node.children) if node.children.any?
+        end
+      end
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#running-ruby--
+      def visit_silent_script(node)
+        group("silent-script") do
+          pp_field("text", node.value[:text])
+          pp_field("children", node.children) if node.children.any?
+        end
+      end
+
+      # Visit a tag node.
+      def visit_tag(node)
+        group("tag") do
+          pp_field("name", node.value[:name])
+
+          if node.value[:attributes].any?
+            pp_field("attributes", node.value[:attributes])
+          end
+
+          if node.value[:dynamic_attributes].new
+            pp_field(
+              "dynamic_attributes.new",
+              node.value[:dynamic_attributes].new
+            )
+          end
+
+          if node.value[:dynamic_attributes].old
+            pp_field(
+              "dynamic_attributes.old",
+              node.value[:dynamic_attributes].old
+            )
+          end
+
+          if node.value[:object_ref] != :nil
+            pp_field("object_ref", node.value[:object_ref])
+          end
+
+          if node.value[:nuke_outer_whitespace]
+            bool_field("nuke_outer_whitespace")
+          end
+
+          if node.value[:nuke_inner_whitespace]
+            bool_field("nuke_inner_whitespace")
+          end
+
+          bool_field("self_closing") if node.value[:self_closing]
+          pp_field("value", node.value[:value]) if node.value[:value]
+          pp_field("children", node.children) if node.children.any?
+        end
+      end
+
+      private
+
+      def bool_field(name)
+        q.breakable
+        q.text(name)
+      end
+
+      def group(name)
+        q.group do
+          q.text("(")
+          q.text(name)
+
+          q.nest(2) { yield }
+          q.breakable("")
+          q.text(")")
+        end
+      end
+
+      def pp_field(name, value)
+        q.breakable
+        q.text(name)
+        q.text("=")
+        q.pp(value)
+      end
+
+      def text_field(name, value)
+        q.breakable
+        q.text(name)
+        q.text("=")
+        q.text(value)
+      end
+    end
+  end
+end

data/lib/syntax_tree/haml/version.rb

@@ -2,6 +2,6 @@
 
 module SyntaxTree
   module Haml
-    VERSION = "1.0.1"
+    VERSION = "1.2.1"
   end
 end

data/lib/syntax_tree/haml.rb

@@ -1,81 +1,86 @@
 # frozen_string_literal: true
 
 require "haml"
+require "prettier_print"
 require "syntax_tree"
 
-require "syntax_tree/haml/comment"
-require "syntax_tree/haml/doctype"
-require "syntax_tree/haml/filter"
-require "syntax_tree/haml/haml_comment"
-require "syntax_tree/haml/plain"
-require "syntax_tree/haml/root"
-require "syntax_tree/haml/script"
-require "syntax_tree/haml/silent_script"
-require "syntax_tree/haml/tag"
-
-class Haml::Parser::ParseNode
-  def format(q)
-    syntax_tree.format(q)
-  end
-
-  def pretty_print(q)
-    syntax_tree.pretty_print(q)
-  end
+module SyntaxTree
+  module Haml
+    DOCTYPE_TYPES = {
+      "basic" => "Basic",
+      "frameset" => "Frameset",
+      "mobile" => "Mobile",
+      "rdfa" => "RDFa",
+      "strict" => "Strict",
+      "xml" => "XML"
+    }
 
-  private
+    DOCTYPE_VERSIONS = %w[1.1 5]
 
-  def syntax_tree
-    case type
-    when :comment then SyntaxTree::Haml::Comment.new(self)
-    when :doctype then SyntaxTree::Haml::Doctype.new(self)
-    when :filter then SyntaxTree::Haml::Filter.new(self)
-    when :haml_comment then SyntaxTree::Haml::HamlComment.new(self)
-    when :plain then SyntaxTree::Haml::Plain.new(self)
-    when :root then SyntaxTree::Haml::Root.new(self)
-    when :script then SyntaxTree::Haml::Script.new(self)
-    when :silent_script then SyntaxTree::Haml::SilentScript.new(self)
-    when :tag then SyntaxTree::Haml::Tag.new(self)
-    else
-      raise ArgumentError, "Unsupported type: #{type}"
+    # This is the parent class of the various visitors that we provide to access
+    # the HAML syntax tree.
+    class Visitor
+      def visit(node)
+        node&.accept(self)
+      end
     end
-  end
-end
 
-module SyntaxTree
-  module Haml
+    # This is the main parser entrypoint, and just delegates to the Haml gem's
+    # parser to do the heavy lifting.
     def self.parse(source)
       ::Haml::Parser.new({}).call(source)
     end
 
-    def self.format(source)
-      formatter = PP.new([])
-      parse(source).format(formatter)
-
-      formatter.flush
-      formatter.output.join
+    # This is the main entrypoint for the formatter. It parses the source,
+    # builds a formatter, then pretty prints the result.
+    def self.format(source, maxwidth = 80)
+      PrettierPrint.format(+"", maxwidth) { |q| parse(source).format(q) }
     end
 
+    # This is a required API for syntax tree which just delegates to File.read.
     def self.read(filepath)
       File.read(filepath)
     end
-
-    def self.with_children(node, q)
-      if node.children.empty?
-        q.group { yield }
-      else
-        q.group do
-          q.group { yield }
-          q.indent do
-            node.children.each do |child|
-              q.breakable(force: true)
-              child.format(q)
-            end
-          end
-        end
-      end
-    end
   end
 
   # Register our module as a handler for the .haml file type.
   register_handler(".haml", Haml)
 end
+
+require "syntax_tree/haml/format"
+require "syntax_tree/haml/pretty_print"
+
+class Haml::Parser::ParseNode
+  # Here we're going to hook into the parse node and define a method that will
+  # accept a visitor in order to walk through the tree.
+  def accept(visitor)
+    case type
+    in :comment
+      visitor.visit_comment(self)
+    in :doctype
+      visitor.visit_doctype(self)
+    in :filter
+      visitor.visit_filter(self)
+    in :haml_comment
+      visitor.visit_haml_comment(self)
+    in :plain
+      visitor.visit_plain(self)
+    in :root
+      visitor.visit_root(self)
+    in :script
+      visitor.visit_script(self)
+    in :silent_script
+      visitor.visit_silent_script(self)
+    in :tag
+      visitor.visit_tag(self)
+    end
+  end
+
+  def format(q)
+    accept(SyntaxTree::Haml::Format.new(q))
+  end
+
+  def pretty_print(q)
+    accept(SyntaxTree::Haml::PrettyPrint.new(q))
+  end
+end

data/syntax_tree-haml.gemspec

@@ -4,27 +4,28 @@ require "ripper"
 require_relative "lib/syntax_tree/haml/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "syntax_tree-haml"
-  spec.version       = SyntaxTree::Haml::VERSION
-  spec.authors       = ["Kevin Newton"]
-  spec.email         = ["kddnewton@gmail.com"]
+  spec.name = "syntax_tree-haml"
+  spec.version = SyntaxTree::Haml::VERSION
+  spec.authors = ["Kevin Newton"]
+  spec.email = ["kddnewton@gmail.com"]
 
-  spec.summary       = "Syntax Tree support for Haml"
-  spec.homepage      = "https://github.com/ruby-syntax-tree/syntax_tree-haml"
-  spec.license       = "MIT"
-  spec.metadata      = { "rubygems_mfa_required" => "true" }
+  spec.summary = "Syntax Tree support for Haml"
+  spec.homepage = "https://github.com/ruby-syntax-tree/syntax_tree-haml"
+  spec.license = "MIT"
+  spec.metadata = { "rubygems_mfa_required" => "true" }
 
-  spec.files         = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      f.match(%r{^(test|spec|features)/})
+  spec.files =
+    Dir.chdir(__dir__) do
+      `git ls-files -z`.split("\x0")
+        .reject { |f| f.match(%r{^(test|spec|features)/}) }
     end
-  end
 
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = %w[lib]
 
   spec.add_dependency "haml", ">= 5.2"
+  spec.add_dependency "prettier_print"
   spec.add_dependency "syntax_tree", ">= 2.0.1"
 
   spec.add_development_dependency "bundler"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_tree-haml
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.1
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-31 00:00:00.000000000 Z
+date: 2022-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: haml
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: prettier_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: syntax_tree
   requirement: !ruby/object:Gem::Requirement
@@ -114,15 +128,8 @@ files:
 - bin/format
 - bin/parse
 - lib/syntax_tree/haml.rb
-- lib/syntax_tree/haml/comment.rb
-- lib/syntax_tree/haml/doctype.rb
-- lib/syntax_tree/haml/filter.rb
-- lib/syntax_tree/haml/haml_comment.rb
-- lib/syntax_tree/haml/plain.rb
-- lib/syntax_tree/haml/root.rb
-- lib/syntax_tree/haml/script.rb
-- lib/syntax_tree/haml/silent_script.rb
-- lib/syntax_tree/haml/tag.rb
+- lib/syntax_tree/haml/format.rb
+- lib/syntax_tree/haml/pretty_print.rb
 - lib/syntax_tree/haml/version.rb
 - syntax_tree-haml.gemspec
 homepage: https://github.com/ruby-syntax-tree/syntax_tree-haml
@@ -145,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.0.dev
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Syntax Tree support for Haml

data/lib/syntax_tree/haml/comment.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  module Haml
-    # https://haml.info/docs/yardoc/file.REFERENCE.html#html-comments-
-    class Comment
-      attr_reader :node
-
-      def initialize(node)
-        @node = node
-      end
-
-      def format(q)
-        Haml.with_children(node, q) do
-          q.text("/")
-          q.text("!") if node.value[:revealed]
-
-          if node.value[:conditional]
-            q.text(node.value[:conditional])
-          elsif node.value[:text]
-            q.text(" #{node.value[:text]}")
-          end
-        end
-      end
-
-      def pretty_print(q)
-        q.group(2, "(comment", ")") do
-          q.breakable
-
-          if node.value[:conditional]
-            q.text("conditional=")
-            q.pp(node.value[:conditional])
-          elsif node.value[:text]
-            q.text("text=")
-            q.pp(node.value[:text])
-          end
-
-          if node.value[:revealed]
-            q.breakable
-            q.text("revealed")
-          end
-
-          if node.children.any?
-            q.breakable
-            q.text("children=")
-            q.pp(node.children)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/syntax_tree/haml/doctype.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  module Haml
-    # https://haml.info/docs/yardoc/file.REFERENCE.html#doctype-
-    class Doctype
-      TYPES = {
-        "basic" => "Basic",
-        "frameset" => "Frameset",
-        "mobile" => "Mobile",
-        "rdfa" => "RDFa",
-        "strict" => "Strict",
-        "xml" => "XML"
-      }
-
-      VERSIONS = ["1.1", "5"]
-
-      attr_reader :node
-
-      def initialize(node)
-        @node = node
-      end
-
-      def format(q)
-        parts = ["!!!"]
-
-        parts <<
-          if TYPES.key?(node.value[:type])
-            TYPES[node.value[:type]]
-          elsif VERSIONS.include?(node.value[:version])
-            node.value[:version]
-          else
-            node.value[:type]
-          end
-
-        parts << node.value[:encoding] if node.value[:encoding]
-        q.text(parts.join(" "))
-      end
-
-      def pretty_print(q)
-        q.group(2, "(doctype", ")") do
-          q.breakable
-
-          if TYPES.key?(node.value[:type])
-            q.text("type=")
-            q.pp(node.value[:type])
-          elsif VERSIONS.include?(node.value[:version])
-            q.text("version=")
-            q.pp(node.value[:version])
-          else
-            q.text("type=")
-            q.pp(node.value[:type])
-          end
-
-          if node.value[:encoding]
-            q.breakable
-            q.text("encoding=")
-            q.pp(node.value[:encoding])
-          end
-        end
-      end
-    end
-  end
-end

data/lib/syntax_tree/haml/filter.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  module Haml
-    # https://haml.info/docs/yardoc/file.REFERENCE.html#filters
-    class Filter
-      attr_reader :node
-
-      def initialize(node)
-        @node = node
-      end
-
-      def format(q)
-        q.group do
-          q.text(":")
-          q.text(node.value[:name])
-
-          q.indent do
-            q.breakable(force: true)
-
-            segments = node.value[:text].strip.split("\n")
-            q.seplist(segments, -> { q.breakable(force: true) }) do |segment|
-              q.text(segment)
-            end
-          end
-        end
-      end
-
-      def pretty_print(q)
-        q.group(2, "(filter", ")") do
-          q.breakable
-          q.text("name=")
-          q.text(node.value[:name])
-
-          q.breakable
-          q.text("text=")
-          q.pp(node.value[:text])
-        end
-      end
-    end
-  end
-end

data/lib/syntax_tree/haml/haml_comment.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  module Haml
-    # https://haml.info/docs/yardoc/file.REFERENCE.html#haml-comments--
-    class HamlComment
-      attr_reader :node
-
-      def initialize(node)
-        @node = node
-      end
-
-      def format(q)
-        q.text("-#")
-        text = node.value[:text].strip
-
-        if text.include?("\n")
-          q.indent do
-            q.breakable(force: true)
-            q.seplist(text.split("\n"), -> { q.breakable(force: true) }) do |segment|
-              q.text(segment)
-            end
-          end
-        else
-          q.text(" #{text}")
-        end
-      end
-
-      def pretty_print(q)
-        q.group(2, "(haml_comment", ")") do
-          q.breakable
-          q.text("text=")
-          q.pp(node.value[:text])
-        end
-      end
-    end
-  end
-end

data/lib/syntax_tree/haml/plain.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  module Haml
-    # https://haml.info/docs/yardoc/file.REFERENCE.html#plain-text
-    class Plain
-      attr_reader :node
-
-      def initialize(node)
-        @node = node
-      end
-
-      def format(q)
-        text = node.value[:text]
-
-        q.text("\\") if escaped?(text)
-        q.text(text)
-      end
-
-      def pretty_print(q)
-        q.group(2, "(plain", ")") do
-          q.breakable
-          q.text("text=")
-          q.pp(node.value[:text])
-        end
-      end
-
-      private
-
-      # If a node comes in as the plain type but starts with one of the special
-      # characters that haml parses, then we need to escape it with a \ when
-      # printing.
-      def escaped?(text)
-        ::Haml::Parser::SPECIAL_CHARACTERS.any? do |special|
-          text.start_with?(special)
-        end
-      end
-    end
-  end
-end

data/lib/syntax_tree/haml/root.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  module Haml
-    class Root
-      attr_reader :node
-
-      def initialize(node)
-        @node = node
-      end
-
-      def format(q)
-        node.children.each do |child|
-          child.format(q)
-          q.breakable(force: true)
-        end
-      end
-
-      def pretty_print(q)
-        q.group(2, "(root", ")") do
-          if node.children.any?
-            q.breakable
-            q.text("children=")
-            q.pp(node.children)
-          end
-        end
-      end
-    end
-  end
-end