haml 6.0.1 → 6.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 909d5636fba736ef06747221b4d0ff34a8c5b850f2c8d4cc60ac27843e914e94
-  data.tar.gz: 478fd2cce0e05e386690aa83fa41132da006cb02437ec43a0b4882842a2e973c
+  metadata.gz: ec341f61274ad9cac37bc7df1c3ca31cfd7cfcb5d049ab9d2d2b505d7d314de9
+  data.tar.gz: 0a3e2dc6d6e03f586d51980e7db967b9626a1ec4563352d195e472756327b734
 SHA512:
-  metadata.gz: 268bfdc33ba76950ab553692c5ff1c45b84a3f3b4185248a19c6a3a74f4b47cd46527d279ed3782f9b7fd6bba6be889a531b7e6c133a4f00ac7e3e06d61a464c
-  data.tar.gz: 1b4f559abe65e3c39627d87b6cc2da894ca67514f62d702ff0920d9d974dda49d4ab7b49e465157622b31a9c3ad5b1925e5e4aa2b1360640d784a7a6f537178a
+  metadata.gz: 529e8c001b4dae92210e8d74f3027367ad826b1f963dec92f6680378ed1b85ddd7285de0dc99e188f6557b1e439fb4157120578af68ef00292aa5a8de11e1e4f
+  data.tar.gz: a1871dcc07d3b0bbd45e30aaab1f0b7d043af90e276fbf163a1645ac72c7891f9d163a928857d2333f23e36955bde20aa1f1b90f373ba0d1ee6e6b285cca33f9

data/.yardopts

@@ -0,0 +1,19 @@
+--charset          utf-8
+--readme           README.md
+--markup           markdown
+--markup-provider  kramdown
+--template-path    yard
+--default-return   ""
+--title            "Haml Documentation"
+--query            'object.type != :classvariable'
+--query            'object.type != :constant || @api && @api.text == "public"'
+--exclude          lib/haml/railtie.rb
+--hide-void-return
+--protected
+--no-private
+--no-highlight
+-
+FAQ.md
+CHANGELOG.md
+REFERENCE.md
+MIT-LICENSE

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Haml Changelog
 
+## 6.0.7
+
+* `Haml::Engine` and `Haml::Template` use StringBuffer instead of ArrayBuffer
+  * It seems more performant in many cases with recent Ruby versions.
+  * `Haml::RailsTemplate` is not affected.
+
+## 6.0.6
+
+* Prevent CRuby from accidentally using the Ruby implementation fallback
+  * Reversing what v6.0.3 and v6.0.4 did, but still supporting Wasm.
+
+## 6.0.5
+
+* Resurrect `#haml_object_ref` support in an object reference [#1097](https://github.com/haml/haml/issues/1097)
+  * This was removed in 6.0.0, and added back in this version.
+* Stop warning `remove_whitespace: true` option.
+
+## 6.0.4
+
+Released on October 2, 2022
+([diff](https://github.com/haml/haml/compare/v6.0.3...v6.0.4)).
+
+* Fix a parse failure of `%` in attributes [#1096](https://github.com/haml/haml/issues/1096)
+* Add another fallback from C to Ruby for Wasm.
+
+## 6.0.3
+
+Released on September 28, 2022
+([diff](https://github.com/haml/haml/compare/v6.0.2...v6.0.3)).
+
+* For Wasm, fallback to Ruby when C extension is not available.
+
+## 6.0.2
+
+Released on September 28, 2022
+([diff](https://github.com/haml/haml/compare/v6.0.1...v6.0.2)).
+
+* Unescape HTML-safe arguments for `surround`, `succeed`, and `precede` on Rails
+  [#1088](https://github.com/haml/haml/issues/1088)
+
 ## 6.0.1
 
 Released on September 23, 2022
@@ -17,7 +57,19 @@ Released on September 21, 2022
   * Haml 6 is about 1.7x faster than Haml 5 in [this benchmark](benchmark/slim/run-benchmarks.rb).
   * The parser is kept as is, but everything else is replaced.
   * The `haml` CLI interface was also replaced.
-  * All Haml helpers except for `preserve` are removed.
+  * The interface of `Haml::Engine` is changed. `Haml::Template` is most likely what you need now.
+  * Most Haml helpers are removed.
+     * Rails:
+         * Kept: `find_and_reserve`, `preserve`, `surround`, `precede`, `succeed`, `capture_haml`
+         * Removed: `block_is_haml?`, `flatten`, `haml_concat`, `haml_indent`, `haml_tag`, `haml_tag_if`, `html_attrs`,
+           `html_escape`, `init_haml_helpers`, `is_haml?`, `list_of`, `non_haml`, `tab_down`, `tab_up`, `with_tabs`
+     * Tilt:
+         * Kept: `preserve`
+         * Removed: `block_is_haml?`, `capture_haml`, `escape_once`, `find_and_preserve`, `flatten`, `haml_concat`,
+           `haml_indent`, `haml_tag`, `haml_tag_if`, `html_attrs`, `html_escape`, `init_haml_helpers`, `is_haml?`,
+           `list_of`, `non_haml`, `precede`, `succeed`, `surround`, `tab_down`, `tab_up`, `with_tabs`
+  * Only the attributes in [`Haml::AttributeBuilder::BOOLEAN_ATTRIBUTES`](lib/haml/attribute_builder.rb)
+    are handled as boolean attributes.
   * Some legacy Rails integration is removed.
 
 ## 5.2.2

data/README.md

@@ -22,7 +22,7 @@ gem install haml
 After you write some Haml, you can run
 
 ~~~sh
-haml document.haml
+haml render document.haml
 ~~~
 
 to compile it to HTML. For more information on these commands, check out
@@ -41,8 +41,8 @@ To use Haml with Rails, simply add Haml to your Gemfile and run `bundle`.
 gem 'haml'
 ~~~
 
-If you'd like to replace Rails's Erb-based generators with Haml, add
-[haml-rails](https://github.com/indirect/haml-rails) to your Gemfile as well.
+If you'd like to replace Rails's ERB-based generators with Haml, add
+[haml-rails](https://github.com/haml/haml-rails) to your Gemfile as well.
 
 ## Formatting
 

data/REFERENCE.md

@@ -30,7 +30,7 @@ The first step for all of these is to install the Haml gem:
 
 To run Haml from the command line, just use
 
-    haml input.haml output.html
+    haml render input.haml > output.html
 
 Use `haml --help` for full documentation.
 
@@ -68,24 +68,6 @@ may be compiled to:
       </div>
     </div>
 
-### Rails XSS Protection
-
-Haml supports Rails' XSS protection scheme, which was introduced in Rails 2.3.5+
-and is enabled by default in 3.0.0+. If it's enabled, Haml's
-{Haml::Options#escape_html `:escape_html`} option is set to `true` by default -
-like in ERB, all strings printed to a Haml template are escaped by default. Also
-like ERB, strings marked as HTML safe are not escaped. Haml also has [its own
-syntax for printing a raw string to the template](#unescaping_html).
-
-If the `:escape_html` option is set to false when XSS protection is enabled,
-Haml doesn't escape Ruby strings by default. However, if a string marked
-HTML-safe is passed to [Haml's escaping syntax](#escaping_html), it won't be
-escaped.
-
-Finally, all the {Haml::Helpers Haml helpers} that return strings that are known
-to be HTML safe are marked as such. In addition, string input is escaped unless
-it's HTML safe.
-
 ### Ruby Module
 
 Haml can also be used completely separately from Rails and ActionView. To do
@@ -93,10 +75,10 @@ this, install the gem with RubyGems:
 
     gem install haml
 
-You can then use it by including the "haml" gem in Ruby code, and using
-{Haml::Engine} like so:
+You can then use it by including the `haml` gem in Ruby code, and using
+{Haml::Template} like so:
 
-    engine = Haml::Engine.new("%p Haml code!")
+    engine = Haml::Template.new { "%p Haml code!" }
     engine.render #=> "<p>Haml code!</p>\n"
 
 ### Options
@@ -104,50 +86,26 @@ You can then use it by including the "haml" gem in Ruby code, and using
 Haml understands various configuration options that affect its performance and
 output.
 
-In Rails, options can be set by setting the {Haml::Template#options Haml::Template.options}
-hash in an initializer:
+In Rails, options can be set by using `Haml::RailsTemplate.set_options` in an initializer:
 
 ```ruby
 # config/initializers/haml.rb
-Haml::Template.options[:format] = :html5
-
-# Avoid escaping attributes which are already escaped
-Haml::Template.options[:escape_attrs] = :once
+Haml::RailsTemplate.set_options(escape_html: false)
 ```
 
-Outside Rails, you can set them by configuring them globally in
-Haml::Options.defaults:
+Outside Rails, you can set them by configuring them globally in `Haml::Template.options`:
 
 ```ruby
-Haml::Options.defaults[:format] = :html5
+Haml::Template.options[:escape_html] = false
 ```
 
 In sinatra specifically, you can set them in global config with:
 ```ruby
-set :haml, { escape_html: true }
+set :haml, { escape_html: false }
 ```
 
-Finally, you can also set them by passing an options hash to
-{Haml::Engine#initialize}. For the complete list of available options, please
-see {Haml::Options}.
-
-### Encodings
-
-Haml supports the same sorts of
-encoding-declaration comments that Ruby does. Although both Ruby and Haml
-support several different styles, the easiest it just to add `-# coding:
-encoding-name` at the beginning of the Haml template (it must come before all
-other lines). This will tell Haml that the template is encoded using the named
-encoding.
-
-By default, the HTML generated by Haml has the same encoding as the Haml
-template. However, if `Encoding.default_internal` is set, Haml will attempt to
-use that instead. In addition, the {Haml::Options#encoding `:encoding` option}
-can be used to specify an output encoding manually.
-
-Note that, like Ruby, Haml does not support templates encoded in UTF-16 or
-UTF-32, since these encodings are not compatible with ASCII. It is possible to
-use these as the output encoding, though.
+Finally, you can also set them by passing an options hash to `Haml::Engine.new` or `Haml::Template.new`.
+For the complete list of available options, please see `Haml::Engine`.
 
 ## Plain Text
 
@@ -325,49 +283,6 @@ Haml also supports Ruby's new hash syntax:
 
     %a{title: @title, href: href} Stuff
 
-#### Attribute Methods
-
-A Ruby method call that returns a hash can be substituted for the hash contents.
-For example, {Haml::Helpers} defines the following method:
-
-    def html_attrs(lang = 'en-US')
-      {:xmlns => "http://www.w3.org/1999/xhtml", 'xml:lang' => lang, :lang => lang}
-    end
-
-This can then be used in Haml, like so:
-
-    %html{html_attrs('fr-fr')}
-
-This is compiled to:
-
-    <html lang='fr-fr' xml:lang='fr-fr' xmlns='http://www.w3.org/1999/xhtml'>
-    </html>
-
-You can use as many such attribute methods as you want by separating them with
-commas, like a Ruby argument list. All the hashes will be merged together, from
-left to right. For example, if you defined
-
-    def hash1
-      {:bread => 'white', :filling => 'peanut butter and jelly'}
-    end
-
-    def hash2
-      {:bread => 'whole wheat'}
-    end
-
-then
-
-    %sandwich{hash1, hash2, :delicious => 'true'}/
-
-would compile to:
-
-    <sandwich bread='whole wheat' delicious='true' filling='peanut butter and jelly' />
-
-Note that the Haml attributes list has the same syntax as a Ruby method call.
-This means that any attribute methods must come before the hash literal.
-
-Attribute methods aren't supported for HTML-style attributes.
-
 #### Boolean Attributes
 
 Some attributes, such as "checked" for `input` tags or "selected" for `option`
@@ -404,6 +319,21 @@ or using `true` and `false`:
 
     %input(selected=true)
 
+This feature works only for attributes that are included in
+[`Haml::AttributeBuilder::BOOLEAN_ATTRIBUTES`](lib/haml/attribute_builder.rb),
+as well as `data-` and `aria-` attributes.
+
+    %input{'data-hidden' => false}
+    %input{'aria-hidden' => false}
+    %input{'xyz-hidden' => false}
+
+will render as:
+
+    <input>
+    <input>
+    <input xyz-hidden='false'>
+
+
 <!-- The title to the next section (Prefixed Attributes) has changed. This
 <a> tag is so old links to here still work. -->
 <a id="html5_custom_data_attributes" style="border:0;"></a>
@@ -993,7 +923,7 @@ is compiled to:
 
 ### Whitespace Preservation: `~` {#tilde}
 
-`~` works just like `=`, except that it runs {Haml::Helpers#find\_and\_preserve}
+`~` works just like `=`, except that it runs {Haml::Helpers.preserve}
 on its input. For example,
 
     ~ "Foo\n<pre>Bar\nBaz</pre>"
@@ -1154,9 +1084,6 @@ is compiled to
       <p>I <strong>really</strong> prefer <em>raspberry</em> jam.</p>
     </div>
 
-Note that `#{}` interpolation within filters is HTML-escaped if you specify true to
-{Haml::Options#escape_filter_interpolations `:escape_filter_interpolations`} option.
-
 The functionality of some filters such as Markdown can be provided by many
 different libraries. Usually you don't have to worry about this - you can just
 load the gem of your choice and Haml will automatically use it.
@@ -1271,43 +1198,48 @@ default. This filter is implemented using Tilt.
 
 ### Custom Filters
 
-You can also define your own filters. See {Haml::Filters} for details.
-
-## Helper Methods {#helper-methods}
-
-Sometimes you need to manipulate whitespace in a more precise fashion than what
-the whitespace removal methods allow. There are a few helper methods that are
-useful when dealing with inline content. All these methods take a Haml block to
-modify.
+You can also define your own filters.
+`Haml::Filters::YourCustomFilter#compile` should return
+[a Temple expression](https://github.com/judofyr/temple/blob/master/EXPRESSIONS.md).
 
-### surround {#surround}
+The simplest example of a filter might be something like:
 
-Surrounds a Haml block with text. Expects 1 or 2 string arguments used to
-surround the Haml block. If a second argument is not provided, the first
-argument is used as the second.
-
-    = surround "(", ")" do
-      = link_to "learn more", "#"
-
-### precede {#precede}
+```ruby
+class HelloFilter < Haml::Filters::Base
+  def compile(_node)
+    [:static, "hello world"]
+  end
+end
 
-Prepends a Haml block with text. Expects 1 argument.
+Haml::Filters.registered[:hello] ||= HelloFilter
+```
 
-    = precede "*" do
-      %span Required
+A more complex complex example
 
-### succeed {#succeed}
+```ruby
+class BetterFilter < Haml::Filters::Base
+  def compile(node)
+    temple = [:multi]
+    temple << [:static, "hello "]
+    temple << compile_text(node.value[:text])
+    temple << [:static, " world"]
+    temple
+  end
+
+  private
+  def compile_text(text)
+    if ::Haml::Util.contains_interpolation?(text)
+      [:dynamic, ::Haml::Util.unescape_interpolation(text)]
+    else
+      [:static, text]
+    end
+  end
+end
 
-Appends a Haml block with text. Expects 1 argument.
+Haml::Filters.registered[:better] ||= BetterFilter
+```
 
-    Begin by
-    = succeed "," do
-      = link_to "filling out your profile", "#"
-    = succeed "," do
-      = link_to "adding a bio", "#"
-    and
-    = succeed "." do
-      = link_to "inviting friends", "#"
+See {Haml::Filters} for examples.
 
 ## Multiline: `|` {#multiline}
 
@@ -1367,14 +1299,7 @@ Haml won't try to re-format the indentation.
 Literal `textarea` and `pre` tags automatically preserve content given through
 `=`. Dynamically-generated `textarea`s and `pre`s can't be preserved
 automatically, and so should be passed through
-{Haml::Helpers#find\_and\_preserve} or the [`~` command](#tilde), which has the
+{Haml::Helpers.preserve} or the [`~` command](#tilde), which has the
 same effect.
 
 Blocks of literal text can be preserved using the [`:preserve` filter](#preserve-filter).
-
-## Helpers
-
-Haml offers a bunch of helpers that are useful for doing stuff like preserving
-whitespace, creating nicely indented output for user-defined helpers, and other
-useful things. The helpers are all documented in the {Haml::Helpers} and
-{Haml::Helpers::ActionViewExtensions} modules.

data/Rakefile

@@ -35,72 +35,14 @@ end
 
 Dir['benchmark/*.rake'].each { |b| import(b) }
 
-namespace :haml do
-  Rake::TestTask.new do |t|
-    t.libs << 'lib' << 'test'
-    files = Dir['test/haml/*_test.rb']
-    files << 'test/haml/haml-spec/*_test.rb'
-    t.ruby_opts = %w[-rtest_helper]
-    t.test_files = files
-    t.verbose = true
-  end
-end
-
-namespace :hamlit do
-  Rake::TestTask.new do |t|
-    t.libs << 'lib' << 'test'
-    t.ruby_opts = %w[-rtest_helper]
-    t.test_files = Dir['test/hamlit/**/*_test.rb']
-    t.verbose = true
-  end
-end
-
-namespace :test do
-  Rake::TestTask.new(:all) do |t|
-    t.libs << 'lib' << 'test'
-    files = Dir['test/hamlit/**/*_test.rb']
-    files += Dir['test/haml/*_test.rb']
-    files << 'test/haml/haml-spec/*_test.rb'
-    t.ruby_opts = %w[-rtest_helper]
-    t.test_files = files
-    t.verbose = true
-  end
-
-  Rake::TestTask.new(:spec) do |t|
-    t.libs << 'lib' << 'test'
-    t.ruby_opts = %w[-rtest_helper]
-    t.test_files = %w[test/haml/haml-spec/ugly_test.rb test/haml/haml-spec/pretty_test.rb]
-    t.verbose = true
-  end
-
-  Rake::TestTask.new(:engine) do |t|
-    t.libs << 'lib' << 'test'
-    t.ruby_opts = %w[-rtest_helper]
-    t.test_files = %w[test/haml/engine_test.rb]
-    t.verbose = true
-  end
-
-  Rake::TestTask.new(:filters) do |t|
-    t.libs << 'lib' << 'test'
-    t.ruby_opts = %w[-rtest_helper]
-    t.test_files = %w[test/haml/filters_test.rb]
-    t.verbose = true
-  end
-
-  Rake::TestTask.new(:helper) do |t|
-    t.libs << 'lib' << 'test'
-    t.ruby_opts = %w[-rtest_helper]
-    t.test_files = %w[test/haml/helper_test.rb]
-    t.verbose = true
-  end
-
-  Rake::TestTask.new(:template) do |t|
-    t.libs << 'lib' << 'test'
-    t.ruby_opts = %w[-rtest_helper]
-    t.test_files = %w[test/haml/template_test.rb]
-    t.verbose = true
-  end
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  files = Dir['test/haml/**/*_test.rb']
+  t.ruby_opts = %w[-rtest_helper]
+  t.test_files = files
+  t.verbose = true
 end
+task test: :compile
 
 desc 'bench task for CI'
 task bench: :compile do
@@ -112,5 +54,29 @@ task bench: :compile do
   exit system(*cmd)
 end
 
-task default: %w[compile hamlit:test]
-task test: %w[compile test:all]
+namespace :doc do
+  task :sass do
+    require 'sass'
+    Dir["yard/default/**/*.sass"].each do |sass|
+      File.open(sass.gsub(/sass$/, 'css'), 'w') do |f|
+        f.write(Sass::Engine.new(File.read(sass)).render)
+      end
+    end
+  end
+
+  desc "List all undocumented methods and classes."
+  task :undocumented do
+    command = 'yard --list --query '
+    command << '"object.docstring.blank? && '
+    command << '!(object.type == :method && object.is_alias?)"'
+    sh command
+  end
+end
+
+desc "Generate documentation"
+task(:doc => 'doc:sass') {sh "yard"}
+
+desc "Generate documentation incrementally"
+task(:redoc) {sh "yard -c"}
+
+task default: %w[compile test]

data/lib/haml/attribute_builder.rb

@@ -9,9 +9,8 @@ module Haml::AttributeBuilder
                        itemscope allowfullscreen default inert sortable
                        truespeed typemustmatch download].freeze
 
-  # Java extension is not implemented for JRuby yet.
-  # TruffleRuby does not implement `rb_ary_sort_bang`, etc.
-  if /java/ === RUBY_PLATFORM || RUBY_ENGINE == 'truffleruby'
+  # For JRuby, TruffleRuby, and Wasm, fallback to Ruby implementation.
+  if /java|wasm/ === RUBY_PLATFORM || RUBY_ENGINE == 'truffleruby'
     class << self
       def build(escape_attrs, quote, format, boolean_attributes, object_ref, *hashes)
         hashes << Haml::ObjectRef.parse(object_ref) if object_ref

data/lib/haml/engine.rb

@@ -3,6 +3,7 @@ require 'temple'
 require 'haml/parser'
 require 'haml/compiler'
 require 'haml/html'
+require 'haml/string_splitter'
 require 'haml/escapable'
 require 'haml/force_escapable'
 require 'haml/dynamic_merger'
@@ -12,7 +13,7 @@ module Haml
   class Engine < Temple::Engine
     define_options(
       :buffer_class,
-      generator:    Temple::Generators::ArrayBuffer,
+      generator:    Temple::Generators::StringBuffer,
       format:       :html,
       attr_quote:   "'",
       escape_html:  true,
@@ -22,12 +23,13 @@ module Haml
                        param source track wbr),
       filename:     "",
       disable_capture: false,
+      remove_whitespace: false,
     )
 
     use Parser
     use Compiler
     use HTML
-    filter :StringSplitter
+    use StringSplitter
     filter :StaticAnalyzer
     use Escapable
     use ForceEscapable

data/lib/haml/object_ref.rb

@@ -6,7 +6,12 @@ module Haml
         object, prefix = args
         return {} unless object
 
-        suffix = underscore(object.class)
+        suffix =
+          if object.respond_to?(:haml_object_ref)
+            object.haml_object_ref
+          else
+            underscore(object.class)
+          end
         {
           'class' => [prefix, suffix].compact.join('_'),
           'id'    => [prefix, suffix, object.id || 'new'].compact.join('_'),

data/lib/haml/rails_helpers.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: false
 require 'haml/helpers'
 
-# Currently this Haml::Helpers depends on
-# ActionView internal implementation. (not desired)
+# There are only helpers that depend on ActionView internals.
 module Haml
   module RailsHelpers
     include Helpers
@@ -32,16 +31,19 @@ module Haml
 
     def surround(front, back = front, &block)
       output = capture_haml(&block)
-
-      "#{escape_once(front)}#{output.chomp}#{escape_once(back)}\n".html_safe
+      front  = escape_once(front) unless front.html_safe?
+      back   = escape_once(back)  unless back.html_safe?
+      "#{front}#{output.chomp}#{back}\n".html_safe
     end
 
     def precede(str, &block)
-      "#{escape_once(str)}#{capture_haml(&block).chomp}\n".html_safe
+      str = escape_once(str) unless str.html_safe?
+      "#{str}#{capture_haml(&block).chomp}\n".html_safe
     end
 
     def succeed(str, &block)
-      "#{capture_haml(&block).chomp}#{escape_once(str)}\n".html_safe
+      str = escape_once(str) unless str.html_safe?
+      "#{capture_haml(&block).chomp}#{str}\n".html_safe
     end
 
     def capture_haml(*args, &block)

data/lib/haml/string_splitter.rb

@@ -1,19 +1,139 @@
 # frozen_string_literal: true
-require 'ripper'
-require 'haml/ruby_expression'
+begin
+  require 'ripper'
+rescue LoadError
+end
 
 module Haml
-  module StringSplitter
-    # `code` param must be valid string literal
-    def self.compile(code)
-      unless Ripper.respond_to?(:lex) # truffleruby doesn't have Ripper.lex
-        return [[:dynamic, code]]
+  # Compile [:dynamic, "foo#{bar}"] to [:multi, [:static, 'foo'], [:dynamic, 'bar']]
+  class StringSplitter < Temple::Filter
+    if defined?(Ripper) && RUBY_VERSION >= "2.0.0" && Ripper.respond_to?(:lex)
+      class << self
+        # `code` param must be valid string literal
+        def compile(code)
+          [].tap do |exps|
+            tokens = Ripper.lex(code.strip)
+            tokens.pop while tokens.last && [:on_comment, :on_sp].include?(tokens.last[1])
+
+            if tokens.size < 2
+              raise(Haml::InternalError, "Expected token size >= 2 but got: #{tokens.size}")
+            end
+            compile_tokens!(exps, tokens)
+          end
+        end
+
+        private
+
+        def strip_quotes!(tokens)
+          _, type, beg_str = tokens.shift
+          if type != :on_tstring_beg
+            raise(Haml::InternalError, "Expected :on_tstring_beg but got: #{type}")
+          end
+
+          _, type, end_str = tokens.pop
+          if type != :on_tstring_end
+            raise(Haml::InternalError, "Expected :on_tstring_end but got: #{type}")
+          end
+
+          [beg_str, end_str]
+        end
+
+        def compile_tokens!(exps, tokens)
+          beg_str, end_str = strip_quotes!(tokens)
+
+          until tokens.empty?
+            _, type, str = tokens.shift
+
+            case type
+            when :on_tstring_content
+              beg_str, end_str = escape_quotes(beg_str, end_str)
+              exps << [:static, eval("#{beg_str}#{str}#{end_str}").to_s]
+            when :on_embexpr_beg
+              embedded = shift_balanced_embexpr(tokens)
+              exps << [:dynamic, embedded] unless embedded.empty?
+            end
+          end
+        end
+
+        # Some quotes are split-unsafe. Replace such quotes with null characters.
+        def escape_quotes(beg_str, end_str)
+          case [beg_str[-1], end_str]
+          when ['(', ')'], ['[', ']'], ['{', '}']
+            [beg_str.sub(/.\z/) { "\0" }, "\0"]
+          else
+            [beg_str, end_str]
+          end
+        end
+
+        def shift_balanced_embexpr(tokens)
+          String.new.tap do |embedded|
+            embexpr_open = 1
+
+            until tokens.empty?
+              _, type, str = tokens.shift
+              case type
+              when :on_embexpr_beg
+                embexpr_open += 1
+              when :on_embexpr_end
+                embexpr_open -= 1
+                break if embexpr_open == 0
+              end
+
+              embedded << str
+            end
+          end
+        end
       end
 
-      begin
-        Temple::Filters::StringSplitter.compile(code)
-      rescue Temple::FilterError => e
-        raise Haml::InternalError.new(e.message)
+      def on_dynamic(code)
+        return [:dynamic, code] unless string_literal?(code)
+        return [:dynamic, code] if code.include?("\n")
+
+        temple = [:multi]
+        StringSplitter.compile(code).each do |type, content|
+          case type
+          when :static
+            temple << [:static, content]
+          when :dynamic
+            temple << on_dynamic(content)
+          end
+        end
+        temple
+      end
+
+      private
+
+      def string_literal?(code)
+        return false if SyntaxChecker.syntax_error?(code)
+
+        type, instructions = Ripper.sexp(code)
+        return false if type != :program
+        return false if instructions.size > 1
+
+        type, _ = instructions.first
+        type == :string_literal
+      end
+
+      class SyntaxChecker < Ripper
+        class ParseError < StandardError; end
+
+        def self.syntax_error?(code)
+          self.new(code).parse
+          false
+        rescue ParseError
+          true
+        end
+
+        private
+
+        def on_parse_error(*)
+          raise ParseError
+        end
+      end
+    else
+      # Do nothing if ripper is unavailable
+      def call(ast)
+        ast
       end
     end
   end

data/lib/haml/util.rb

@@ -14,9 +14,8 @@ module Haml
   module Util
     extend self
 
-    # Java extension is not implemented for JRuby yet.
-    # TruffleRuby does not implement `rb_ary_sort_bang`, etc.
-    if /java/ === RUBY_PLATFORM || RUBY_ENGINE == 'truffleruby'
+    # For JRuby, TruffleRuby, and Wasm, fallback to Ruby implementation.
+    if /java|wasm/ === RUBY_PLATFORM || RUBY_ENGINE == 'truffleruby'
       require 'cgi/escape'
 
       def self.escape_html(html)

data/lib/haml/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Haml
-  VERSION = '6.0.1'
+  VERSION = '6.0.7'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haml
 version: !ruby/object:Gem::Version
-  version: 6.0.1
+  version: 6.0.7
 platform: ruby
 authors:
 - Natalie Weizenbaum
@@ -9,10 +9,10 @@ authors:
 - Norman Clarke
 - Akira Matsuda
 - Takashi Kokubun
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-23 00:00:00.000000000 Z
+date: 2022-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: temple
@@ -265,6 +265,7 @@ files:
 - ".github/FUNDING.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
+- ".yardopts"
 - CHANGELOG.md
 - FAQ.md
 - Gemfile
@@ -337,7 +338,7 @@ homepage: https://haml.info
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -353,7 +354,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.3.7
-signing_key:
+signing_key: 
 specification_version: 4
 summary: An elegant, structured (X)HTML/XML templating engine.
 test_files: []