haml 5.0.4 → 6.0.0

data/lib/haml/exec.rb

@@ -1,348 +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 }
-
-      # 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)
-        begin
-          eval("BEGIN {return nil}; #{code}", binding, @options[:filename] || "")
-        rescue ::SyntaxError # Not to be confused with Haml::SyntaxError
-          $!
-        end
-      end
-    end
-  end
-end

data/lib/haml/generator.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: false
-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

data/lib/haml/helpers/action_view_extensions.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-module Haml
-  module Helpers
-    @@action_view_defined = true
-
-    # This module contains various useful helper methods
-    # that either tie into ActionView or the rest of the ActionPack stack,
-    # or are only useful in that context.
-    # Thus, the methods defined here are only available
-    # if ActionView is installed.
-    module ActionViewExtensions
-      # Returns a value for the "class" attribute
-      # unique to this controller/action pair.
-      # This can be used to target styles specifically at this action or controller.
-      # For example, if the current action were `EntryController#show`,
-      #
-      #     %div{:class => page_class} My Div
-      #
-      # would become
-      #
-      #     <div class="entry show">My Div</div>
-      #
-      # Then, in a stylesheet (shown here as [Sass](http://sass-lang.com)),
-      # you could refer to this specific action:
-      #
-      #     .entry.show
-      #       font-weight: bold
-      #
-      # or to all actions in the entry controller:
-      #
-      #     .entry
-      #       color: #00f
-      #
-      # @return [String] The class name for the current page
-      def page_class
-        "#{controller.controller_name} #{controller.action_name}"
-      end
-      alias_method :generate_content_class_names, :page_class
-
-      # Treats all input to \{Haml::Helpers#haml\_concat} within the block
-      # as being HTML safe for Rails' XSS protection.
-      # This is useful for wrapping blocks of code that concatenate HTML en masse.
-      #
-      # This has no effect if Rails' XSS protection isn't enabled.
-      #
-      # @yield A block in which all input to `#haml_concat` is treated as raw.
-      # @see Haml::Util#rails_xss_safe?
-      def with_raw_haml_concat
-        old = instance_variable_defined?(:@_haml_concat_raw) ? @_haml_concat_raw : false
-        @_haml_concat_raw = true
-        yield
-      ensure
-        @_haml_concat_raw = old
-      end
-    end
-
-    include ActionViewExtensions
-  end
-end

data/lib/haml/helpers/action_view_mods.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-module Haml
-  module Helpers
-    module ActionViewMods
-      def render(*args, &block)
-        options = args.first
-
-        # If render :layout is used with a block, it concats rather than returning
-        # a string so we need it to keep thinking it's Haml until it hits the
-        # sub-render.
-        if is_haml? && !(options.is_a?(Hash) && options[:layout] && block_given?)
-          return non_haml { super }
-        end
-        super
-      end
-
-      def output_buffer
-        return haml_buffer.buffer if is_haml?
-        super
-      end
-
-      def output_buffer=(new_buffer)
-        if is_haml?
-          if Haml::Util.rails_xss_safe? && new_buffer.is_a?(ActiveSupport::SafeBuffer)
-            new_buffer = String.new(new_buffer)
-          end
-          haml_buffer.buffer = new_buffer
-        else
-          super
-        end
-      end
-    end
-    ActionView::Base.send(:prepend, ActionViewMods)
-  end
-end
-
-module ActionView
-  module Helpers
-    module CaptureHelper
-      def capture_with_haml(*args, &block)
-        if Haml::Helpers.block_is_haml?(block)
-          #double assignment is to avoid warnings
-          _hamlout = _hamlout = eval('_hamlout', block.binding) # Necessary since capture_haml checks _hamlout
-
-          capture_haml(*args, &block)
-        else
-          capture_without_haml(*args, &block)
-        end
-      end
-      alias_method :capture_without_haml, :capture
-      alias_method :capture, :capture_with_haml
-    end
-
-    module TagHelper
-      def content_tag_with_haml(name, *args, &block)
-        return content_tag_without_haml(name, *args, &block) unless is_haml?
-
-        preserve = haml_buffer.options.fetch(:preserve, %w[textarea pre code]).include?(name.to_s)
-
-        if block_given? && block_is_haml?(block) && preserve
-          return content_tag_without_haml(name, *args) do
-            haml_buffer.fix_textareas!(Haml::Helpers.preserve(&block)).html_safe
-          end
-        end
-
-        content = content_tag_without_haml(name, *args, &block)
-        if preserve && content
-          content = haml_buffer.fix_textareas!(Haml::Helpers.preserve(content)).html_safe
-        end
-        content
-      end
-
-      alias_method :content_tag_without_haml, :content_tag
-      alias_method :content_tag, :content_tag_with_haml
-    end
-
-    module HamlSupport
-      include Haml::Helpers
-
-      def haml_buffer
-        @template_object.send :haml_buffer
-      end
-
-      def is_haml?
-        @template_object.send :is_haml?
-      end
-    end
-
-    module Tags
-      class TextArea
-        include HamlSupport
-      end
-    end
-
-    class InstanceTag
-      include HamlSupport
-
-      def content_tag(*args, &block)
-        html_tag = content_tag_with_haml(*args, &block)
-        return html_tag unless respond_to?(:error_wrapping)
-        return error_wrapping(html_tag) if method(:error_wrapping).arity == 1
-        return html_tag unless object.respond_to?(:errors) && object.errors.respond_to?(:on)
-        return error_wrapping(html_tag, object.errors.on(@method_name))
-      end
-    end
-
-    module FormTagHelper
-      def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
-        if is_haml?
-          wrap_block = block_given? && block_is_haml?(proc)
-          if wrap_block
-            oldproc = proc
-            proc = haml_bind_proc do |*args|
-              concat "\n"
-              with_tabs(1) {oldproc.call(*args)}
-            end
-          end
-          res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) << "\n"
-          res << "\n" if wrap_block
-          res
-        else
-          form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
-        end
-      end
-      alias_method :form_tag_without_haml, :form_tag
-      alias_method :form_tag, :form_tag_with_haml
-    end
-  end
-end

data/lib/haml/helpers/action_view_xss_mods.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-module ActionView
-  module Helpers
-    module CaptureHelper
-      def with_output_buffer_with_haml_xss(*args, &block)
-        res = with_output_buffer_without_haml_xss(*args, &block)
-        case res
-        when Array; res.map {|s| Haml::Util.html_safe(s)}
-        when String; Haml::Util.html_safe(res)
-        else; res
-        end
-      end
-      alias_method :with_output_buffer_without_haml_xss, :with_output_buffer
-      alias_method :with_output_buffer, :with_output_buffer_with_haml_xss
-    end
-
-    module FormTagHelper
-      def form_tag_with_haml_xss(*args, &block)
-        res = form_tag_without_haml_xss(*args, &block)
-        res = Haml::Util.html_safe(res) unless block_given?
-        res
-      end
-      alias_method :form_tag_without_haml_xss, :form_tag
-      alias_method :form_tag, :form_tag_with_haml_xss
-    end
-
-    module FormHelper
-      def form_for_with_haml_xss(*args, &block)
-        res = form_for_without_haml_xss(*args, &block)
-        return Haml::Util.html_safe(res) if res.is_a?(String)
-        return res
-      end
-      alias_method :form_for_without_haml_xss, :form_for
-      alias_method :form_for, :form_for_with_haml_xss
-    end
-
-    module TextHelper
-      def concat_with_haml_xss(string)
-        if is_haml?
-          haml_buffer.buffer.concat(haml_xss_html_escape(string))
-        else
-          concat_without_haml_xss(string)
-        end
-      end
-      alias_method :concat_without_haml_xss, :concat
-      alias_method :concat, :concat_with_haml_xss
-
-      def safe_concat_with_haml_xss(string)
-        if is_haml?
-          haml_buffer.buffer.concat(string)
-        else
-          safe_concat_without_haml_xss(string)
-        end
-      end
-      alias_method :safe_concat_without_haml_xss, :safe_concat
-      alias_method :safe_concat, :safe_concat_with_haml_xss
-    end
-  end
-end

data/lib/haml/helpers/safe_erubi_template.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-require 'action_view'
-
-module Haml
-  class ErubiTemplateHandler < ActionView::Template::Handlers::ERB::Erubi
-
-    def initialize(*args, &blk)
-      @newline_pending = 0
-      super
-    end
-  end
-
-  class SafeErubiTemplate < Tilt::ErubiTemplate
-    def prepare
-      @options.merge! engine_class: Haml::ErubiTemplateHandler
-      super
-    end
-  end
-end

data/lib/haml/helpers/safe_erubis_template.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-require 'action_view'
-
-module Haml
-
-  class ErubisTemplateHandler < ActionView::Template::Handlers::Erubis
-
-    def initialize(*args, &blk)
-      @newline_pending = 0
-      super
-    end
-  end
-
-  class SafeErubisTemplate < Tilt::ErubisTemplate
-
-    def initialize_engine
-    end
-
-    def prepare
-      @options.merge! :engine_class => Haml::ErubisTemplateHandler
-      super
-    end
-
-    def precompiled_preamble(locals)
-      [super, "@output_buffer = ActionView::OutputBuffer.new;"].join("\n")
-    end
-
-    def precompiled_postamble(locals)
-      [super, '@output_buffer.to_s'].join("\n")
-    end
-  end
-end