syntax_tree-haml 1.0.1 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92743881ec6d45fc9351e4feb1121e630bd10ac8c9f719b15c5a02b9271c3d59
-  data.tar.gz: 2cdab254a71ec97c4c356fcd9b16377c9e7c07648e7dce5aa99182fbe5e53826
+  metadata.gz: 3ec66452fbab00bf664cbd1d86b9b351a039eb99ac70547dc2defd72003122da
+  data.tar.gz: 5e643711d3d79a8e7c37bc6f17afbb9d855eab2fbf7992f348014cd14ead9490
 SHA512:
-  metadata.gz: f802bec379fe6834229c178ff0e419b3498f66341b60c8d8c949f617fa19180433523f36f8aedca9788a76b6dbce99d572894af6f9ec0fd1583494b86393310b
-  data.tar.gz: cdb61f50440567ef2eeecdfd4edc41fba68443bc62c46b9c51e1c29569fe312e60142e9123f6676f9a0dfbf2248b1e664ac4afc800e077dbe526e918b8c89189
+  metadata.gz: 6a55f022617f25d7898f92ebdcca872cd3920e2177144dc63caa117a8a12bf4c15ee9ec9ad5dedd65312b64191fdf40725b6e83bf1733066e6055901bc374699
+  data.tar.gz: b06d3310d759f3b11fda480172d66253edc1843740f59aef360a7ca5e7d2130d171ee27d272e73a52038ac50b7f1345dcb0a8a4c89a85c3f4a98914a73aee1c9

data/.github/workflows/main.yml

@@ -4,6 +4,13 @@ on:
 - pull_request_target
 jobs:
   ci:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+        - '2.7'
+        - '3.0'
+        - '3.1'
     name: CI
     runs-on: ubuntu-latest
     env:
@@ -13,9 +20,11 @@ jobs:
     - uses: ruby/setup-ruby@v1
       with:
         bundler-cache: true
-        ruby-version: '3.1'
+        ruby-version: ${{ matrix.ruby }}
     - name: Test
-      run: bundle exec rake test
+      run: |
+        bundle exec rake test
+        bundle exec rake stree:check
   automerge:
     name: AutoMerge
     needs: ci

data/CHANGELOG.md

@@ -6,6 +6,24 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [1.2.1] - 2022-07-22
+
+### Changed
+
+- Fix formatting for when empty `%div` or `%div` with no attributes and just children is present.
+
+## [1.2.0] - 2022-05-13
+
+### Added
+
+- An optional `maxwidth` second argument to `SyntaxTree::Haml.format`.
+
+## [1.1.0] - 2022-04-22
+
+### Added
+
+- Support for Ruby 2.7 added back.
+
 ## [1.0.1] - 2022-03-31
 
 ### Changed
@@ -24,7 +42,10 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 - 🎉 Initial release! 🎉
 
-[unreleased]: https://github.com/ruby-syntax-tree/syntax_tree-haml/compare/v1.0.1...HEAD
+[unreleased]: https://github.com/ruby-syntax-tree/syntax_tree-haml/compare/v1.2.1...HEAD
+[1.2.1]: https://github.com/ruby-syntax-tree/syntax_tree-haml/compare/v1.2.0...v1.2.1
+[1.2.0]: https://github.com/ruby-syntax-tree/syntax_tree-haml/compare/v1.1.0...v1.2.0
+[1.1.0]: https://github.com/ruby-syntax-tree/syntax_tree-haml/compare/v1.0.1...v1.1.0
 [1.0.1]: https://github.com/ruby-syntax-tree/syntax_tree-haml/compare/v1.0.0...v1.0.1
 [1.0.0]: https://github.com/ruby-syntax-tree/syntax_tree-haml/compare/v0.1.0...v1.0.0
 [0.1.0]: https://github.com/ruby-syntax-tree/syntax_tree-haml/compare/c1264c...v0.1.0

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    syntax_tree-haml (1.0.1)
+    syntax_tree-haml (1.2.1)
       haml (>= 5.2)
+      prettier_print
       syntax_tree (>= 2.0.1)
 
 GEM
@@ -12,7 +13,8 @@ GEM
     haml (5.2.2)
       temple (>= 0.8.0)
       tilt
-    minitest (5.15.0)
+    minitest (5.16.2)
+    prettier_print (0.1.0)
     rake (13.0.6)
     simplecov (0.21.2)
       docile (~> 1.1)
@@ -20,11 +22,15 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
-    syntax_tree (2.0.1)
+    syntax_tree (3.2.0)
+      prettier_print
     temple (0.8.2)
     tilt (2.0.10)
 
 PLATFORMS
+  ruby
+  x86_64-darwin-19
+  x86_64-darwin-20
   x86_64-darwin-21
   x86_64-linux
 

data/Rakefile

@@ -2,6 +2,7 @@
 
 require "bundler/gem_tasks"
 require "rake/testtask"
+require "syntax_tree/rake_tasks"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
@@ -9,4 +10,10 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
+SOURCE_FILES =
+  FileList[%w[Gemfile Rakefile syntax_tree-haml.gemspec lib/**/*.rb test/*.rb]]
+
+SyntaxTree::Rake::CheckTask.new { |t| t.source_files = SOURCE_FILES }
+SyntaxTree::Rake::WriteTask.new { |t| t.source_files = SOURCE_FILES }
+
 task default: :test

data/lib/syntax_tree/haml/format.rb

@@ -0,0 +1,425 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module Haml
+    class Format < Visitor
+      attr_reader :q
+
+      def initialize(q)
+        @q = q
+      end
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#html-comments-
+      def visit_comment(node)
+        with_children(node) 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
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#doctype-
+      def visit_doctype(node)
+        parts = ["!!!"]
+
+        parts << if DOCTYPE_TYPES.key?(node.value[:type])
+          DOCTYPE_TYPES[node.value[:type]]
+        elsif DOCTYPE_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
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#filter
+      def visit_filter(node)
+        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
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#haml-comments--
+      def visit_haml_comment(node)
+        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) }
+            ) { |segment| q.text(segment) }
+          end
+        else
+          q.text(" #{text}")
+        end
+      end
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#plain-text
+      def visit_plain(node)
+        text = node.value[:text]
+        q.text("\\") if escaped?(text)
+        q.text(text)
+      end
+
+      # Visit the root node of the AST.
+      def visit_root(node)
+        node.children.each do |child|
+          visit(child)
+          q.breakable(force: true)
+        end
+      end
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#inserting_ruby
+      def visit_script(node)
+        with_children(node) do
+          q.text("&") if node.value[:escape_html]
+
+          node.value[:preserve] ? q.text("~") : q.text("=")
+
+          q.text(" ")
+          q.text(node.value[:text].strip)
+        end
+      end
+
+      # https://haml.info/docs/yardoc/file.REFERENCE.html#running-ruby--
+      def visit_silent_script(node)
+        q.group do
+          q.text("- ")
+          q.text(node.value[:text].strip)
+
+          node.children.each do |child|
+            if continuation?(node, child)
+              q.breakable(force: true)
+              visit(child)
+            else
+              q.indent do
+                q.breakable(force: true)
+                visit(child)
+              end
+            end
+          end
+        end
+      end
+
+      LiteralHashValue = Struct.new(:value)
+
+      # When formatting a tag, there are a lot of different kinds of things that
+      # can be printed out. There's the tag name, the attributes, the content,
+      # etc. This object is responsible for housing all of those parts.
+      class PartList
+        attr_reader :node, :parts
+
+        def initialize(node)
+          @node = node
+          @parts = []
+        end
+
+        def <<(part)
+          parts << part
+        end
+
+        def empty?
+          parts.empty?
+        end
+
+        def format(q)
+          if empty? && node.value[:name] == "div"
+            # If we don't have any other parts to print and the tag is a div
+            # then we need to make sure to add that to the beginning. Otherwise
+            # it's implied by the presence of other operators.
+            q.text("%div")
+          else
+            parts.inject(0) do |align, part|
+              part.format(q, align)
+              align + part.length
+            end
+          end
+        end
+      end
+
+      class PlainPart < Struct.new(:value)
+        def format(q, align)
+          q.text(value)
+        end
+
+        def length
+          value.length
+        end
+      end
+
+      class PrefixPart < Struct.new(:prefix, :value)
+        def format(q, align)
+          q.text("#{prefix}#{value}")
+        end
+
+        def length
+          prefix.length + value.length
+        end
+      end
+
+      class HTMLAttributesPart
+        attr_reader :values
+
+        def initialize(raw)
+          @values =
+            raw[1...-1]
+              .split(",")
+              .to_h { |keypair| keypair[1..-1].split("\" => ") }
+        end
+
+        def format(q, align)
+          q.group do
+            q.text("(")
+            q.nest(align) do
+              q.seplist(
+                values,
+                -> { q.fill_breakable },
+                :each_pair
+              ) { |key, value| q.text("#{key}=#{value}") }
+            end
+            q.text(")")
+          end
+        end
+
+        def length
+          values.sum { |key, value| key.length + value.length + 3 }
+        end
+      end
+
+      class HashAttributesPart < Struct.new(:values)
+        def format(q, align)
+          format_value(q, values)
+        end
+
+        def length
+          values.sum do |key, value|
+            key.length + (value.is_a?(String) ? value : value.to_s).length + 3
+          end
+        end
+
+        private
+
+        def format_value(q, hash, level = 0)
+          q.group do
+            q.text("{")
+            q.indent do
+              q.group do
+                q.breakable(level == 0 ? "" : " ")
+                q.seplist(hash, nil, :each_pair) do |key, value|
+                  q.text(Format.hash_key(key))
+                  q.text(" ")
+
+                  if value.is_a?(Hash)
+                    format_value(q, value, level + 1)
+                  else
+                    q.text(Format.hash_value(value))
+                  end
+                end
+              end
+            end
+
+            q.breakable(level == 0 ? "" : " ")
+            q.text("}")
+          end
+        end
+      end
+
+      def self.hash_key(key)
+        key.match?(/^@|[-:]/) ? "\"#{key}\":" : "#{key}:"
+      end
+
+      def self.hash_value(value)
+        case value
+        when LiteralHashValue
+          value.value
+        when String
+          "\"#{Quotes.normalize(value, "\"")}\""
+        else
+          value.to_s
+        end
+      end
+
+      # Visit a tag node.
+      def visit_tag(node)
+        parts = PartList.new(node)
+
+        # If we have a tag that isn't a div, then we need to print out that
+        # name of that tag first. If it is a div, first we'll check if there
+        # are any other things that would force us to print out the div
+        # explicitly, and otherwise we'll leave it off.
+        if node.value[:name] != "div"
+          parts << PrefixPart.new("%", node.value[:name])
+        end
+
+        # If we have a class attribute, then we're going to print that here
+        # using the special class syntax.
+        if node.value[:attributes].key?("class")
+          parts << PrefixPart.new(
+            ".",
+            node.value[:attributes]["class"].tr(" ", ".")
+          )
+        end
+
+        # If we have an id attribute, then we're going to print that here
+        # using the special id syntax.
+        if node.value[:attributes].key?("id")
+          parts << PrefixPart.new("#", node.value[:attributes]["id"])
+        end
+
+        # If we're using dynamic attributes on this tag, then they come in as
+        # a string that looks like the output of Hash#inspect from Ruby. So
+        # here we're going to split it all up and print it out nicely.
+        if node.value[:dynamic_attributes].new
+          parts << HTMLAttributesPart.new(node.value[:dynamic_attributes].new)
+        end
+
+        # If there are any static attributes that are not class or id (because
+        # we already took care of those), then we're going to print them out
+        # here.
+        static =
+          node.value[:attributes].reject do |key, _|
+            key == "class" || key == "id"
+          end
+
+        parts << HashAttributesPart.new(static) if static.any?
+
+        # If there are dynamic attributes that don't use the newer syntax, then
+        # we're going to print them out here.
+        if node.value[:dynamic_attributes].old
+          parts << PlainPart.new("%div") if parts.empty?
+
+          if ::Haml::AttributeParser.available?
+            dynamic = parse_attributes(node.value[:dynamic_attributes].old)
+            parts << if dynamic.is_a?(LiteralHashValue)
+              PlainPart.new(dynamic.value)
+            else
+              HashAttributesPart.new(dynamic)
+            end
+          else
+            parts << PlainPart.new(node.value[:dynamic_attributes].old)
+          end
+        end
+
+        # https://haml.info/docs/yardoc/file.REFERENCE.html#object-reference-
+        if node.value[:object_ref] != :nil
+          parts << PlainPart.new("%div") if parts.empty?
+          parts << PlainPart.new(node.value[:object_ref])
+        end
+
+        # https://haml.info/docs/yardoc/file.REFERENCE.html#whitespace-removal--and-
+        parts << PlainPart.new(">") if node.value[:nuke_outer_whitespace]
+        parts << PlainPart.new("<") if node.value[:nuke_inner_whitespace]
+
+        # https://haml.info/docs/yardoc/file.REFERENCE.html#empty-void-tags-
+        parts << PlainPart.new("/") if node.value[:self_closing]
+
+        # If there is a value part, then we're going to print slightly
+        # differently as the value goes after the tag declaration.
+        if (value = node.value[:value]) && !value.empty?
+          with_children(node) do
+            q.group { parts.format(q) }
+            q.indent do
+              # Split between the declaration of the tag and the contents of the
+              # tag.
+              q.breakable("")
+
+              if node.value[:parse] && value.match?(/#[{$@]/)
+                # There's a weird case here where if the value includes
+                # interpolation and it's marked as { parse: true }, then we
+                # don't actually want the = prefix, and we want to remove extra
+                # escaping.
+                q.if_break { q.text("") }.if_flat { q.text(" ") }
+                q.text(value[1...-1].gsub(/\\"/, "\""))
+              elsif node.value[:parse]
+                q.text("= ")
+                q.text(value)
+              else
+                q.if_break { q.text("") }.if_flat { q.text(" ") }
+                q.text(value)
+              end
+            end
+          end
+        else
+          with_children(node) { parts.format(q) }
+        end
+      end
+
+      private
+
+      # When printing out sequences of silent scripts, sometimes subsequent nodes
+      # will be continuations of previous nodes. In that case we want to dedent
+      # them to match.
+      def continuation?(node, 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
+
+      # 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
+
+      # Take a source string and attempt to parse it into a set of attributes that
+      # can be used to format the source.
+      def parse_attributes(source)
+        case Ripper.sexp(source)
+        in [:program, [[:hash, *], *]] if parsed =
+             ::Haml::AttributeParser.parse(source)
+          parsed.to_h { |key, value| [key, parse_attributes(value)] }
+        in [:program, [[:string_literal, *], *]]
+          source[1...-1]
+        else
+          LiteralHashValue.new(source)
+        end
+      end
+
+      def with_children(node)
+        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)
+                visit(child)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end