haml 5.2.1 → 6.0.0.beta.2

data/benchmark.rb

@@ -1,70 +0,0 @@
-require "bundler/setup"
-require "haml"
-require "rbench"
-
-times = (ARGV.first || 1000).to_i
-
-if times == 0 # Invalid parameter
-  puts <<END
-ruby #$0 [times=1000]
-  Benchmark Haml against various other templating languages.
-END
-  exit 1
-end
-
-%w[erb erubi rails active_support action_controller
-   action_view action_pack haml/template rbench].each {|dep| require(dep)}
-
-def view
-  base = ActionView::Base.new
-  base.view_paths << File.join(File.dirname(__FILE__), '/test')
-  base
-end
-
-def render(view, file)
-  view.render :file => file
-end
-
-RBench.run(times) do
-  column :haml, :title => "Haml"
-  column :erb, :title => "ERB"
-  column :erubi, :title => "Erubi"
-
-  template_name = 'standard'
-  haml_template    = File.read("#{File.dirname(__FILE__)}/test/templates/#{template_name}.haml")
-  erb_template     = File.read("#{File.dirname(__FILE__)}/test/erb/#{template_name}.erb")
-
-  report "Cached" do
-    obj = Object.new
-
-    Haml::Engine.new(haml_template).def_method(obj, :haml)
-    if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
-      obj.instance_eval("def erb; #{ERB.new(erb_template, trim_mode: '-').src}; end")
-    else
-      obj.instance_eval("def erb; #{ERB.new(erb_template, nil, '-').src}; end")
-    end
-    obj.instance_eval("def erubi; #{Erubi::Engine.new(erb_template).src}; end")
-
-    haml      { obj.haml }
-    erb       { obj.erb }
-    erubi     { obj.erubi }
-  end
-
-  report "ActionView" do
-    # To cache the template
-    render view, 'templates/standard'
-    render view, 'erb/standard'
-
-    haml  { render view, 'templates/standard' }
-    erubi { render view, 'erb/standard' }
-  end
-
-  report "ActionView with deep partials" do
-    # To cache the template
-    render view, 'templates/action_view'
-    render view, 'erb/action_view'
-
-    haml  { render view, 'templates/action_view' }
-    erubi { render view, 'erb/action_view' }
-  end
-end

data/bin/haml

@@ -1,9 +0,0 @@
-#!/usr/bin/env ruby
-# The command line Haml parser.
-
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-require 'haml'
-require 'haml/exec'
-
-opts = Haml::Exec::Haml.new(ARGV)
-opts.parse!

data/lib/haml/.gitattributes

@@ -1 +0,0 @@
-version.rb merge=ours

data/lib/haml/buffer.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-
-module Haml
-  # This class is used only internally. It holds the buffer of HTML that
-  # is eventually output as the resulting document.
-  # It's called from within the precompiled code,
-  # and helps reduce the amount of processing done within `instance_eval`ed code.
-  class Buffer
-    include Haml::Helpers
-    include Haml::Util
-
-    # The string that holds the compiled HTML. This is aliased as
-    # `_erbout` for compatibility with ERB-specific code.
-    #
-    # @return [String]
-    attr_accessor :buffer
-
-    # The options hash passed in from {Haml::Engine}.
-    #
-    # @return [{String => Object}]
-    # @see Haml::Options#for_buffer
-    attr_accessor :options
-
-    # The {Buffer} for the enclosing Haml document.
-    # This is set for partials and similar sorts of nested templates.
-    # It's `nil` at the top level (see \{#toplevel?}).
-    #
-    # @return [Buffer]
-    attr_accessor :upper
-
-    # nil if there's no capture_haml block running,
-    # and the position at which it's beginning the capture if there is one.
-    #
-    # @return [Fixnum, nil]
-    attr_accessor :capture_position
-
-    # @return [Boolean]
-    # @see #active?
-    attr_writer :active
-
-    # @return [Boolean] Whether or not the format is XHTML
-    def xhtml?
-      not html?
-    end
-
-    # @return [Boolean] Whether or not the format is any flavor of HTML
-    def html?
-      html4? or html5?
-    end
-
-    # @return [Boolean] Whether or not the format is HTML4
-    def html4?
-      @options[:format] == :html4
-    end
-
-    # @return [Boolean] Whether or not the format is HTML5.
-    def html5?
-      @options[:format] == :html5
-    end
-
-    # @return [Boolean] Whether or not this buffer is a top-level template,
-    #   as opposed to a nested partial
-    def toplevel?
-      upper.nil?
-    end
-
-    # Whether or not this buffer is currently being used to render a Haml template.
-    # Returns `false` if a subtemplate is being rendered,
-    # even if it's a subtemplate of this buffer's template.
-    #
-    # @return [Boolean]
-    def active?
-      @active
-    end
-
-    # @return [Fixnum] The current indentation level of the document
-    def tabulation
-      @real_tabs + @tabulation
-    end
-
-    # Sets the current tabulation of the document.
-    #
-    # @param val [Fixnum] The new tabulation
-    def tabulation=(val)
-      val = val - @real_tabs
-      @tabulation = val > -1 ? val : 0
-    end
-
-    # @param upper [Buffer] The parent buffer
-    # @param options [{Symbol => Object}] An options hash.
-    #   See {Haml::Engine#options\_for\_buffer}
-    def initialize(upper = nil, options = {})
-      @active     = true
-      @upper      = upper
-      @options    = Options.buffer_defaults
-      @options    = @options.merge(options) unless options.empty?
-      @buffer     = new_encoded_string
-      @tabulation = 0
-
-      # The number of tabs that Engine thinks we should have
-      # @real_tabs + @tabulation is the number of tabs actually output
-      @real_tabs = 0
-    end
-
-    # Appends text to the buffer, properly tabulated.
-    # Also modifies the document's indentation.
-    #
-    # @param text [String] The text to append
-    # @param tab_change [Fixnum] The number of tabs by which to increase
-    #   or decrease the document's indentation
-    # @param dont_tab_up [Boolean] If true, don't indent the first line of `text`
-    def push_text(text, tab_change, dont_tab_up)
-      if @tabulation > 0
-        # Have to push every line in by the extra user set tabulation.
-        # Don't push lines with just whitespace, though,
-        # because that screws up precompiled indentation.
-        text.gsub!(/^(?!\s+$)/m, tabs)
-        text.sub!(tabs, '') if dont_tab_up
-      end
-
-      @real_tabs += tab_change
-      @buffer << text
-    end
-
-    # Modifies the indentation of the document.
-    #
-    # @param tab_change [Fixnum] The number of tabs by which to increase
-    #   or decrease the document's indentation
-    def adjust_tabs(tab_change)
-      @real_tabs += tab_change
-    end
-
-    def attributes(class_id, obj_ref, *attributes_hashes)
-      attributes = class_id
-      attributes_hashes.each do |old|
-        result = {}
-        old.each { |k, v| result[k.to_s] = v }
-        AttributeBuilder.merge_attributes!(attributes, result)
-      end
-      AttributeBuilder.merge_attributes!(attributes, parse_object_ref(obj_ref)) if obj_ref
-      AttributeBuilder.build_attributes(
-        html?, @options[:attr_wrapper], @options[:escape_attrs], @options[:hyphenate_data_attrs], attributes)
-    end
-
-    # Remove the whitespace from the right side of the buffer string.
-    # Doesn't do anything if we're at the beginning of a capture_haml block.
-    def rstrip!
-      if capture_position.nil?
-        buffer.rstrip!
-        return
-      end
-
-      buffer << buffer.slice!(capture_position..-1).rstrip
-    end
-
-    # Works like #{find_and_preserve}, but allows the first newline after a
-    # preserved opening tag to remain unencoded, and then outdents the content.
-    # This change was motivated primarily by the change in Rails 3.2.3 to emit
-    # a newline after textarea helpers.
-    #
-    # @param input [String] The text to process
-    # @since Haml 4.0.1
-    # @private
-    def fix_textareas!(input)
-      return input unless input.include?('<textarea'.freeze)
-
-      pattern = /<(textarea)([^>]*)>(\n|&#x000A;)(.*?)<\/textarea>/im
-      input.gsub!(pattern) do |s|
-        match = pattern.match(s)
-        content = match[4]
-        if match[3] == '&#x000A;'
-          content.sub!(/\A /, '&#x0020;')
-        else
-          content.sub!(/\A[ ]*/, '')
-        end
-        "<#{match[1]}#{match[2]}>\n#{content}</#{match[1]}>"
-      end
-      input
-    end
-
-    private
-
-    def new_encoded_string
-      "".encode(options[:encoding])
-    end
-
-    @@tab_cache = {}
-    # Gets `count` tabs. Mostly for internal use.
-    def tabs(count = 0)
-      tabs = [count + @tabulation, 0].max
-      @@tab_cache[tabs] ||= '  ' * tabs
-    end
-
-    # Takes an array of objects and uses the class and id of the first
-    # one to create an attributes hash.
-    # The second object, if present, is used as a prefix,
-    # just like you can do with `dom_id()` and `dom_class()` in Rails
-    def parse_object_ref(ref)
-      prefix = ref[1]
-      ref = ref[0]
-      # Let's make sure the value isn't nil. If it is, return the default Hash.
-      return {} if ref.nil?
-      class_name =
-        if ref.respond_to?(:haml_object_ref)
-          ref.haml_object_ref
-        else
-          underscore(ref.class)
-        end
-      ref_id =
-        if ref.respond_to?(:to_key)
-          key = ref.to_key
-          key.join('_') unless key.nil?
-        else
-          ref.id
-        end
-      id = "#{class_name}_#{ref_id || 'new'}"
-      if prefix
-        class_name = "#{ prefix }_#{ class_name}"
-        id = "#{ prefix }_#{ id }"
-      end
-
-      { 'id'.freeze => id, 'class'.freeze => class_name }
-    end
-
-    # Changes a word from camel case to underscores.
-    # Based on the method of the same name in Rails' Inflector,
-    # but copied here so it'll run properly without Rails.
-    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

data/lib/haml/exec.rb

@@ -1,347 +0,0 @@
-# frozen_string_literal: true
-
-require 'optparse'
-require 'rbconfig'
-require 'pp'
-
-module Haml
-  # This module handles the various Haml executables (`haml` and `haml-convert`).
-  module Exec
-    # An abstract class that encapsulates the executable code for all three executables.
-    class Generic
-      # @param args [Array<String>] The command-line arguments
-      def initialize(args)
-        @args = args
-        @options = {:for_engine => {}}
-      end
-
-      # Parses the command-line arguments and runs the executable.
-      # Calls `Kernel#exit` at the end, so it never returns.
-      #
-      # @see #parse
-      def parse!
-        begin
-          parse
-        rescue Exception => e
-          raise e if @options[:trace] || e.is_a?(SystemExit)
-
-          $stderr.print "#{e.class}: " unless e.class == RuntimeError
-          $stderr.puts "#{e.message}"
-          $stderr.puts "  Use --trace for backtrace."
-          exit 1
-        end
-        exit 0
-      end
-
-      # Parses the command-line arguments and runs the executable.
-      # This does not handle exceptions or exit the program.
-      #
-      # @see #parse!
-      def parse
-        @opts = OptionParser.new(&method(:set_opts))
-        @opts.parse!(@args)
-
-        process_result
-
-        @options
-      end
-
-      # @return [String] A description of the executable
-      def to_s
-        @opts.to_s
-      end
-
-      protected
-
-      # Finds the line of the source template
-      # on which an exception was raised.
-      #
-      # @param exception [Exception] The exception
-      # @return [String] The line number
-      def get_line(exception)
-        # SyntaxErrors have weird line reporting
-        # when there's trailing whitespace,
-        # which there is for Haml documents.
-        return (exception.message.scan(/:(\d+)/).first || ["??"]).first if exception.is_a?(::SyntaxError)
-        (exception.backtrace[0].scan(/:(\d+)/).first || ["??"]).first
-      end
-
-      # Tells optparse how to parse the arguments
-      # available for all executables.
-      #
-      # This is meant to be overridden by subclasses
-      # so they can add their own options.
-      #
-      # @param opts [OptionParser]
-      def set_opts(opts)
-        opts.on('-s', '--stdin', :NONE, 'Read input from standard input instead of an input file') do
-          @options[:input] = $stdin
-        end
-
-        opts.on('--trace', :NONE, 'Show a full traceback on error') do
-          @options[:trace] = true
-        end
-
-        opts.on('--unix-newlines', 'Use Unix-style newlines in written files.') do
-          # Note that this is the preferred way to check for Windows, since
-          # JRuby and Rubinius also run there.
-          if RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i
-            @options[:unix_newlines] = true
-          end
-        end
-
-        opts.on_tail("-?", "-h", "--help", "Show this message") do
-          puts opts
-          exit
-        end
-
-        opts.on_tail("-v", "--version", "Print version") do
-          puts("Haml #{::Haml::VERSION}")
-          exit
-        end
-      end
-
-      # Processes the options set by the command-line arguments.
-      # In particular, sets `@options[:input]` and `@options[:output]`
-      # to appropriate IO streams.
-      #
-      # This is meant to be overridden by subclasses
-      # so they can run their respective programs.
-      def process_result
-        input, output = @options[:input], @options[:output]
-        args = @args.dup
-        input ||=
-          begin
-            filename = args.shift
-            @options[:filename] = filename
-            open_file(filename) || $stdin
-          end
-        output ||= open_file(args.shift, 'w') || $stdout
-
-        @options[:input], @options[:output] = input, output
-      end
-
-      COLORS = {red: 31, green: 32, yellow: 33}.freeze
-
-      # Prints a status message about performing the given action,
-      # colored using the given color (via terminal escapes) if possible.
-      #
-      # @param name [#to_s] A short name for the action being performed.
-      #   Shouldn't be longer than 11 characters.
-      # @param color [Symbol] The name of the color to use for this action.
-      #   Can be `:red`, `:green`, or `:yellow`.
-      def puts_action(name, color, arg)
-        return if @options[:for_engine][:quiet]
-        printf color(color, "%11s %s\n"), name, arg
-      end
-
-      # Same as `Kernel.puts`, but doesn't print anything if the `--quiet` option is set.
-      #
-      # @param args [Array] Passed on to `Kernel.puts`
-      def puts(*args)
-        return if @options[:for_engine][:quiet]
-        Kernel.puts(*args)
-      end
-
-      # Wraps the given string in terminal escapes
-      # causing it to have the given color.
-      # If terminal esapes aren't supported on this platform,
-      # just returns the string instead.
-      #
-      # @param color [Symbol] The name of the color to use.
-      #   Can be `:red`, `:green`, or `:yellow`.
-      # @param str [String] The string to wrap in the given color.
-      # @return [String] The wrapped string.
-      def color(color, str)
-        raise "[BUG] Unrecognized color #{color}" unless COLORS[color]
-
-        # Almost any real Unix terminal will support color,
-        # so we just filter for Windows terms (which don't set TERM)
-        # and not-real terminals, which aren't ttys.
-        return str if ENV["TERM"].nil? || ENV["TERM"].empty? || !STDOUT.tty?
-        return "\e[#{COLORS[color]}m#{str}\e[0m"
-      end
-
-      private
-
-      def open_file(filename, flag = 'r')
-        return if filename.nil?
-        flag = 'wb' if @options[:unix_newlines] && flag == 'w'
-        File.open(filename, flag)
-      end
-
-      def handle_load_error(err)
-        dep = err.message[/^no such file to load -- (.*)/, 1]
-        raise err if @options[:trace] || dep.nil? || dep.empty?
-        $stderr.puts <<MESSAGE
-Required dependency #{dep} not found!
-    Run "gem install #{dep}" to get it.
-  Use --trace for backtrace.
-MESSAGE
-        exit 1
-      end
-    end
-
-    # The `haml` executable.
-    class Haml < Generic
-      # @param args [Array<String>] The command-line arguments
-      def initialize(args)
-        super
-        @options[:for_engine] = {}
-        @options[:requires] = []
-        @options[:load_paths] = []
-      end
-
-      # Tells optparse how to parse the arguments.
-      #
-      # @param opts [OptionParser]
-      def set_opts(opts)
-        super
-
-        opts.banner = <<END
-Usage: haml [options] [INPUT] [OUTPUT]
-
-Description:
-  Converts Haml files to HTML.
-
-Options:
-END
-
-        opts.on('-c', '--check', "Just check syntax, don't evaluate.") do
-          require 'stringio'
-          @options[:check_syntax] = true
-          @options[:output] = StringIO.new
-        end
-
-        opts.on('-f', '--format NAME',
-                'Output format. Can be html5 (default), xhtml, or html4.') do |name|
-          @options[:for_engine][:format] = name.to_sym
-        end
-
-        opts.on('-e', '--escape-html',
-                'Escape HTML characters (like ampersands and angle brackets) by default.') do
-          @options[:for_engine][:escape_html] = true
-        end
-
-        opts.on('--no-escape-attrs',
-                "Don't escape HTML characters (like ampersands and angle brackets) in attributes.") do
-          @options[:for_engine][:escape_attrs] = false
-        end
-
-        opts.on('-q', '--double-quote-attributes',
-                'Set attribute wrapper to double-quotes (default is single).') do
-          @options[:for_engine][:attr_wrapper] = '"'
-        end
-
-        opts.on('--remove-whitespace',
-                'Remove whitespace surrounding and within tags') do
-          @options[:for_engine][:remove_whitespace] = true
-        end
-
-        opts.on('--cdata',
-                'Always add CDATA sections to javascript and css blocks.') do
-          @options[:for_engine][:cdata] = true
-        end
-
-        opts.on('--autoclose LIST',
-                'Comma separated list of elements to be automatically self-closed.') do |list|
-          @options[:for_engine][:autoclose] = list.split(',')
-        end
-
-        opts.on('--suppress-eval',
-                'Don\'t evaluate Ruby scripts.') do
-          @options[:for_engine][:suppress_eval] = true
-        end
-
-        opts.on('-r', '--require FILE', "Same as 'ruby -r'.") do |file|
-          @options[:requires] << file
-        end
-
-        opts.on('-I', '--load-path PATH', "Same as 'ruby -I'.") do |path|
-          @options[:load_paths] << path
-        end
-
-        opts.on('-E ex[:in]', 'Specify the default external and internal character encodings.') do |encoding|
-          external, internal = encoding.split(':')
-          Encoding.default_external = external if external && !external.empty?
-          Encoding.default_internal = internal if internal && !internal.empty?
-        end
-
-        opts.on('-d', '--debug', "Print out the precompiled Ruby source, and show syntax errors in the Ruby code.") do
-          @options[:debug] = true
-        end
-
-        opts.on('-p', '--parse', "Print out Haml parse tree.") do
-          @options[:parse] = true
-        end
-
-      end
-
-      # Processes the options set by the command-line arguments,
-      # and runs the Haml compiler appropriately.
-      def process_result
-        super
-        @options[:for_engine][:filename] = @options[:filename]
-        input = @options[:input]
-        output = @options[:output]
-
-        template = input.read()
-        input.close() if input.is_a? File
-
-        @options[:load_paths].each {|p| $LOAD_PATH << p}
-        @options[:requires].each {|f| require f}
-
-        begin
-
-          if @options[:parse]
-            parser = ::Haml::Parser.new(::Haml::Options.new(@options))
-            pp parser.call(template)
-            return
-          end
-
-          engine = ::Haml::Engine.new(template, @options[:for_engine])
-
-          if @options[:check_syntax]
-            error = validate_ruby(engine.precompiled)
-            if error
-              puts error.message.split("\n").first
-              exit 1
-            end
-            puts "Syntax OK"
-            return
-          end
-
-          if @options[:debug]
-            puts engine.precompiled
-            error = validate_ruby(engine.precompiled)
-            if error
-              puts '=' * 100
-              puts error.message.split("\n")[0]
-              exit 1
-            end
-            return
-          end
-
-          result = engine.to_html
-        rescue Exception => e
-          raise e if @options[:trace]
-
-          case e
-          when ::Haml::SyntaxError; raise "Syntax error on line #{get_line e}: #{e.message}"
-          when ::Haml::Error;       raise "Haml error on line #{get_line e}: #{e.message}"
-          else raise "Exception on line #{get_line e}: #{e.message}"
-          end
-        end
-
-        output.write(result)
-        output.close() if output.is_a? File
-      end
-
-      def validate_ruby(code)
-        eval("BEGIN {return nil}; #{code}", binding, @options[:filename] || "")
-      rescue ::SyntaxError # Not to be confused with Haml::SyntaxError
-        $!
-      end
-    end
-  end
-end

data/lib/haml/generator.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Haml
-  # Ruby code generator, which is a limited version of Temple::Generator.
-  # Limit methods since Haml doesn't need most of them.
-  class Generator
-    include Temple::Mixins::CompiledDispatcher
-    include Temple::Mixins::Options
-
-    define_options freeze_static: RUBY_VERSION >= '2.1'
-
-    def call(exp)
-      compile(exp)
-    end
-
-    def on_multi(*exp)
-      exp.map { |e| compile(e) }.join('; ')
-    end
-
-    def on_static(text)
-      concat(options[:freeze_static] ? "#{Util.inspect_obj(text)}.freeze" : Util.inspect_obj(text))
-    end
-
-    def on_dynamic(code)
-      concat(code)
-    end
-
-    def on_code(exp)
-      exp
-    end
-
-    def on_newline
-      "\n"
-    end
-
-    private
-
-    def concat(str)
-      "_hamlout.buffer << (#{str});"
-    end
-  end
-end