haml 6.0.0.beta.1-java

data/lib/haml/filters/javascript.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Javascript < TextBase
+      def compile(node)
+        case @format
+        when :xhtml
+          compile_xhtml(node)
+        else
+          compile_html(node)
+        end
+      end
+
+      private
+
+      def compile_html(node)
+        temple = [:multi]
+        temple << [:static, "<script>\n"]
+        compile_text!(temple, node, '  ')
+        temple << [:static, "\n</script>"]
+        temple
+      end
+
+      def compile_xhtml(node)
+        temple = [:multi]
+        temple << [:static, "<script type='text/javascript'>\n  //<![CDATA[\n"]
+        compile_text!(temple, node, '    ')
+        temple << [:static, "\n  //]]>\n</script>"]
+        temple
+      end
+    end
+  end
+end

data/lib/haml/filters/less.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# LESS support is deprecated since it requires therubyracer.gem,
+# which is hard to maintain.
+#
+# It's not supported in Sprockets 3.0+ too.
+# https://github.com/sstephenson/sprockets/pull/547
+module Haml
+  class Filters
+    class Less < TiltBase
+      def compile(node)
+        require 'tilt/less' if explicit_require?('less')
+        temple = [:multi]
+        temple << [:static, "<style>\n"]
+        temple << compile_with_tilt(node, 'less', indent_width: 2)
+        temple << [:static, '</style>']
+        temple
+      end
+    end
+  end
+end

data/lib/haml/filters/markdown.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Markdown < TiltBase
+      def compile(node)
+        require 'tilt/redcarpet' if explicit_require?('markdown')
+        compile_with_tilt(node, 'markdown')
+      end
+    end
+  end
+end

data/lib/haml/filters/plain.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'haml/string_splitter'
+
+module Haml
+  class Filters
+    class Plain < Base
+      def compile(node)
+        text = node.value[:text]
+        text = text.rstrip unless ::Haml::Util.contains_interpolation?(text) # for compatibility
+        [:multi, *compile_plain(text)]
+      end
+
+      private
+
+      def compile_plain(text)
+        string_literal = ::Haml::Util.unescape_interpolation(text)
+        StringSplitter.compile(string_literal).map do |temple|
+          type, str = temple
+          case type
+          when :dynamic
+            [:escape, false, [:dynamic, str]]
+          else
+            temple
+          end
+        end
+      end
+    end
+  end
+end

data/lib/haml/filters/preserve.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Preserve < Base
+      def compile(node)
+        text = node.value[:text].rstrip + "\n"
+        text = text.gsub("\n", '&#x000A;')
+        compile_text(text)
+      end
+
+      private
+
+      def compile_text(text)
+        if ::Haml::Util.contains_interpolation?(text)
+          [:dynamic, ::Haml::Util.unescape_interpolation(text)]
+        else
+          [:static, text]
+        end
+      end
+    end
+  end
+end

data/lib/haml/filters/ruby.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Ruby < Base
+      def compile(node)
+        [:code, node.value[:text]]
+      end
+    end
+  end
+end

data/lib/haml/filters/sass.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Sass < TiltBase
+      def compile(node)
+        require 'tilt/sass' if explicit_require?('sass')
+        temple = [:multi]
+        temple << [:static, "<style>\n"]
+        temple << compile_with_tilt(node, 'sass', indent_width: 2)
+        temple << [:static, "</style>"]
+        temple
+      end
+    end
+  end
+end

data/lib/haml/filters/scss.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class Scss < TiltBase
+      def compile(node)
+        require 'tilt/sass' if explicit_require?('scss')
+        temple = [:multi]
+        temple << [:static, "<style>\n"]
+        temple << compile_with_tilt(node, 'scss', indent_width: 2)
+        temple << [:static, "</style>"]
+        temple
+      end
+    end
+  end
+end

data/lib/haml/filters/text_base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Haml
+  class Filters
+    class TextBase < Base
+      def compile_text!(temple, node, prefix)
+        text = node.value[:text].rstrip.gsub(/^/, prefix)
+        if ::Haml::Util.contains_interpolation?(node.value[:text])
+          # original: Haml::Filters#compile
+          text = ::Haml::Util.unescape_interpolation(text).gsub(/(\\+)n/) do |s|
+            escapes = $1.size
+            next s if escapes % 2 == 0
+            "#{'\\' * (escapes - 1)}\n"
+          end
+          text.prepend("\n")
+          temple << [:dynamic, text]
+        else
+          node.value[:text].split("\n").size.times do
+            temple << [:newline]
+          end
+          temple << [:static, text]
+        end
+      end
+    end
+  end
+end

data/lib/haml/filters/tilt_base.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require 'tilt'
+
+module Haml
+  class Filters
+    class TiltBase < Base
+      def self.render(name, source, indent_width: 0)
+        text = ::Tilt["t.#{name}"].new { source }.render
+        return text if indent_width == 0
+        text.gsub!(/^/, ' ' * indent_width)
+      end
+
+      def explicit_require?(needed_registration)
+        Gem::Version.new(Tilt::VERSION) >= Gem::Version.new('2.0.0') &&
+          !Tilt.registered?(needed_registration)
+      end
+
+      private
+
+      def compile_with_tilt(node, name, indent_width: 0)
+        if ::Haml::Util.contains_interpolation?(node.value[:text])
+          dynamic_compile(node, name, indent_width: indent_width)
+        else
+          static_compile(node, name, indent_width: indent_width)
+        end
+      end
+
+      def static_compile(node, name, indent_width: 0)
+        temple = [:multi, [:static, TiltBase.render(name, node.value[:text], indent_width: indent_width)]]
+        node.value[:text].split("\n").size.times do
+          temple << [:newline]
+        end
+        temple
+      end
+
+      def dynamic_compile(node, name, indent_width: 0)
+        # original: Haml::Filters#compile
+        text = ::Haml::Util.unescape_interpolation(node.value[:text]).gsub(/(\\+)n/) do |s|
+          escapes = $1.size
+          next s if escapes % 2 == 0
+          "#{'\\' * (escapes - 1)}\n"
+        end
+        text.prepend("\n").sub!(/\n"\z/, '"')
+
+        [:dynamic, "::Haml::Filters::TiltBase.render('#{name}', #{text}, indent_width: #{indent_width})"]
+      end
+    end
+  end
+end

data/lib/haml/filters.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require 'haml/filters/base'
+require 'haml/filters/text_base'
+require 'haml/filters/tilt_base'
+require 'haml/filters/coffee'
+require 'haml/filters/css'
+require 'haml/filters/erb'
+require 'haml/filters/escaped'
+require 'haml/filters/javascript'
+require 'haml/filters/less'
+require 'haml/filters/markdown'
+require 'haml/filters/plain'
+require 'haml/filters/preserve'
+require 'haml/filters/ruby'
+require 'haml/filters/sass'
+require 'haml/filters/scss'
+require 'haml/filters/cdata'
+
+module Haml
+  class Filters
+    @registered = {}
+
+    class << self
+      attr_reader :registered
+
+      def remove_filter(name)
+        registered.delete(name.to_s.downcase.to_sym)
+        if constants.map(&:to_s).include?(name.to_s)
+          remove_const name.to_sym
+        end
+      end
+
+      private
+
+      def register(name, compiler)
+        registered[name] = compiler
+      end
+    end
+
+    register :coffee,       Coffee
+    register :coffeescript, CoffeeScript
+    register :css,          Css
+    register :erb,          Erb
+    register :escaped,      Escaped
+    register :javascript,   Javascript
+    register :less,         Less
+    register :markdown,     Markdown
+    register :plain,        Plain
+    register :preserve,     Preserve
+    register :ruby,         Ruby
+    register :sass,         Sass
+    register :scss,         Scss
+    register :cdata,        Cdata
+
+    def initialize(options = {})
+      @options = options
+      @compilers = {}
+    end
+
+    def compile(node)
+      node.value[:text] ||= ''
+      find_compiler(node).compile(node)
+    end
+
+    private
+
+    def find_compiler(node)
+      name = node.value[:name].to_sym
+      compiler = Filters.registered[name]
+      raise FilterNotFound.new("FilterCompiler for '#{name}' was not found", node.line.to_i - 1) unless compiler
+
+      @compilers[name] ||= compiler.new(@options)
+    end
+  end
+end

data/lib/haml/force_escapable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'haml/escapable'
+
+module Haml
+  # This module allows Temple::Filter to dispatch :fescape on `#compile`.
+  module FescapeDispathcer
+    def on_fescape(flag, exp)
+      [:fescape, flag, compile(exp)]
+    end
+  end
+  ::Temple::Filter.include FescapeDispathcer
+
+  # Unlike Haml::Escapable, this escapes value even if it's html_safe.
+  class ForceEscapable < Escapable
+    def initialize(opts = {})
+      super
+      @escape_code = options[:escape_code] || "::Haml::Util.escape_html((%s))"
+      @escaper = eval("proc {|v| #{@escape_code % 'v'} }")
+    end
+
+    alias_method :on_fescape, :on_escape
+
+    # ForceEscapable doesn't touch :escape expression.
+    # This method is not used if it's inserted after Haml::Escapable.
+    def on_escape(flag, exp)
+      [:escape, flag, compile(exp)]
+    end
+  end
+end

data/lib/haml/haml_error.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Haml
+  # An exception raised by Haml code.
+  # TODO: unify Haml::Error (former Hamlit::Error) and Haml::HamlError (former Haml::Error)
+  class HamlError < StandardError
+
+    MESSAGES = {
+      bad_script_indent:            '"%s" is indented at wrong level: expected %d, but was at %d.',
+      cant_run_filter:              'Can\'t run "%s" filter; you must require its dependencies first',
+      cant_use_tabs_and_spaces:     "Indentation can't use both tabs and spaces.",
+      deeper_indenting:             "The line was indented %d levels deeper than the previous line.",
+      filter_not_defined:           'Filter "%s" is not defined.',
+      gem_install_filter_deps:      '"%s" filter\'s %s dependency missing: try installing it or adding it to your Gemfile',
+      illegal_element:              "Illegal element: classes and ids must have values.",
+      illegal_nesting_content:      "Illegal nesting: nesting within a tag that already has content is illegal.",
+      illegal_nesting_header:       "Illegal nesting: nesting within a header command is illegal.",
+      illegal_nesting_line:         "Illegal nesting: content can't be both given on the same line as %%%s and nested within it.",
+      illegal_nesting_plain:        "Illegal nesting: nesting within plain text is illegal.",
+      illegal_nesting_self_closing: "Illegal nesting: nesting within a self-closing tag is illegal.",
+      inconsistent_indentation:     "Inconsistent indentation: %s used for indentation, but the rest of the document was indented using %s.",
+      indenting_at_start:           "Indenting at the beginning of the document is illegal.",
+      install_haml_contrib:         'To use the "%s" filter, please install the haml-contrib gem.',
+      invalid_attribute_list:       'Invalid attribute list: %s.',
+      invalid_filter_name:          'Invalid filter name ":%s".',
+      invalid_tag:                  'Invalid tag: "%s".',
+      missing_if:                   'Got "%s" with no preceding "if"',
+      no_ruby_code:                 "There's no Ruby code for %s to evaluate.",
+      self_closing_content:         "Self-closing tags can't have content.",
+      unbalanced_brackets:          'Unbalanced brackets.',
+      no_end:                       <<-END
+You don't need to use "- end" in Haml. Un-indent to close a block:
+- if foo?
+  %strong Foo!
+- else
+  Not foo.
+%p This line is un-indented, so it isn't part of the "if" block
+END
+    }.freeze
+
+    def self.message(key, *args)
+      string = MESSAGES[key] or raise "[HAML BUG] No error messages for #{key}"
+      (args.empty? ? string : string % args).rstrip
+    end
+
+    # The line of the template on which the error occurred.
+    #
+    # @return [Fixnum]
+    attr_reader :line
+
+    # @param message [String] The error message
+    # @param line [Fixnum] See \{#line}
+    def initialize(message = nil, line = nil)
+      super(message)
+      @line = line
+    end
+  end
+
+  # SyntaxError is the type of exception raised when Haml encounters an
+  # ill-formatted document.
+  # It's not particularly interesting,
+  # except in that it's a subclass of {Haml::HamlError}.
+  class HamlSyntaxError < HamlError; end
+
+  class HamlInvalidAttributeNameError < HamlSyntaxError; end
+end

data/lib/haml/helpers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Haml
+  module Helpers
+    def self.preserve(input)
+      s = input.to_s.chomp("\n")
+      s.gsub!(/\n/, '
')
+      s.delete!("\r")
+      s
+    end
+
+    def preserve(input)
+      Helpers.preserve(input)
+    end
+  end
+end

data/lib/haml/html.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Haml
+  class HTML < Temple::HTML::Fast
+    DEPRECATED_FORMATS = %i[html4 html5].freeze
+
+    def initialize(opts = {})
+      if DEPRECATED_FORMATS.include?(opts[:format])
+        opts = opts.dup
+        opts[:format] = :html
+      end
+      super(opts)
+    end
+
+    # This dispatcher supports Haml's "revealed" conditional comment.
+    def on_html_condcomment(condition, content, revealed = false)
+      on_html_comment [:multi,
+                       [:static, "[#{condition}]>#{'<!-->' if revealed}"],
+                       content,
+                       [:static, "#{'<!--' if revealed}<![endif]"]]
+    end
+  end
+end

data/lib/haml/identity.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Haml
+  class Identity
+    def initialize
+      @unique_id = 0
+    end
+
+    def generate
+      @unique_id += 1
+      "_haml_compiler#{@unique_id}"
+    end
+  end
+end

data/lib/haml/object_ref.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Haml
+  module ObjectRef
+    class << self
+      def parse(args)
+        object, prefix = args
+        return {} unless object
+
+        suffix = underscore(object.class)
+        {
+          'class' => [prefix, suffix].compact.join('_'),
+          'id'    => [prefix, suffix, object.id || 'new'].compact.join('_'),
+        }
+      end
+
+      private
+
+      # Haml::Buffer.underscore
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/::/, '_')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        word.tr!('-', '_')
+        word.downcase!
+        word
+      end
+    end
+  end
+end