syntax_tree-haml 1.2.0 → 1.2.1

data/lib/syntax_tree/haml.rb

@@ -4,75 +4,83 @@ 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
 
+    # 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,24 +4,24 @@ 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"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syntax_tree-haml
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-14 00:00:00.000000000 Z
+date: 2022-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: haml
@@ -128,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

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

data/lib/syntax_tree/haml/script.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  module Haml
-    # https://haml.info/docs/yardoc/file.REFERENCE.html#inserting_ruby
-    class Script
-      attr_reader :node
-
-      def initialize(node)
-        @node = node
-      end
-
-      def format(q)
-        Haml.with_children(node, q) do
-          q.text("&") if node.value[:escape_html]
-
-          if node.value[:preserve]
-            q.text("~")
-          else
-            q.text("=")
-          end
-
-          q.text(" ")
-          q.text(node.value[:text].strip)
-        end
-      end
-
-      def pretty_print(q)
-        q.group(2, "(script", ")") do
-          q.breakable
-          q.text("text=")
-          q.pp(node.value[:text])
-
-          if node.value[:escape_html]
-            q.breakable
-            q.text("escape_html")
-          end
-
-          if node.value[:preserve]
-            q.breakable
-            q.text("preserve")
-          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/silent_script.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module SyntaxTree
-  module Haml
-    # https://haml.info/docs/yardoc/file.REFERENCE.html#running-ruby--
-    class SilentScript
-      attr_reader :node
-
-      def initialize(node)
-        @node = node
-      end
-
-      def format(q)
-        q.group do
-          q.text("- ")
-          q.text(node.value[:text].strip)
-
-          node.children.each do |child|
-            if continuation?(child)
-              q.breakable(force: true)
-              child.format(q)
-            else
-              q.indent do
-                q.breakable(force: true)
-                child.format(q)
-              end
-            end
-          end
-        end
-      end
-
-      def pretty_print(q)
-        q.group(2, "(silent_script", ")") do
-          q.breakable
-          q.text("text=")
-          q.pp(node.value[:text])
-
-          if node.children.any?
-            q.breakable
-            q.text("children=")
-            q.pp(node.children)
-          end
-        end
-      end
-
-      private
-
-      def continuation?(child)
-        return false if child.type != :silent_script
-
-        case [node.value[:keyword], child.value[:keyword]]
-        in ["case", "in" | "when" | "else"]
-          true
-        in ["if" | "unless", "elsif" | "else"]
-          true
-        else
-          false
-        end
-      end
-    end
-  end
-end