brakeman 7.0.2 → 7.1.0

data/bundle/ruby/3.1.0/gems/haml-5.2.2/lib/haml/engine.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-require 'haml/parser'
-require 'haml/compiler'
-require 'haml/options'
-require 'haml/helpers'
-require 'haml/buffer'
-require 'haml/filters'
-require 'haml/error'
-require 'haml/temple_engine'
-
-module Haml
-  # This is the frontend for using Haml programmatically.
-  # It can be directly used by the user by creating a
-  # new instance and calling \{#render} to render the template.
-  # For example:
-  #
-  #     template = File.read('templates/really_cool_template.haml')
-  #     haml_engine = Haml::Engine.new(template)
-  #     output = haml_engine.render
-  #     puts output
-  class Engine
-    extend Forwardable
-    include Haml::Util
-
-    # The Haml::Options instance.
-    # See {file:REFERENCE.md#options the Haml options documentation}.
-    #
-    # @return Haml::Options
-    attr_accessor :options
-
-    # The indentation used in the Haml document,
-    # or `nil` if the indentation is ambiguous
-    # (for example, for a single-level document).
-    #
-    # @return [String]
-    attr_accessor :indentation
-
-    # Tilt currently depends on these moved methods, provide a stable API
-    def_delegators :compiler, :precompiled, :precompiled_method_return_value
-
-    def options_for_buffer
-      @options.for_buffer
-    end
-
-    # Precompiles the Haml template.
-    #
-    # @param template [String] The Haml template
-    # @param options [{Symbol => Object}] An options hash;
-    #   see {file:REFERENCE.md#options the Haml options documentation}
-    # @raise [Haml::Error] if there's a Haml syntax error in the template
-    def initialize(template, options = {})
-      # Reflect changes of `Haml::Options.defaults` to `Haml::TempleEngine` options, but `#initialize_encoding`
-      # should be run against the arguemnt `options[:encoding]` for backward compatibility with old `Haml::Engine`.
-      options = Options.defaults.dup.tap { |o| o.delete(:encoding) }.merge!(options)
-      @options = Options.new(options)
-
-      @template = check_haml_encoding(template) do |msg, line|
-        raise Haml::Error.new(msg, line)
-      end
-
-      @temple_engine = TempleEngine.new(options)
-      @temple_engine.compile(@template)
-    end
-
-    # Deprecated API for backword compatibility
-    def compiler
-      @temple_engine
-    end
-
-    # Processes the template and returns the result as a string.
-    #
-    # `scope` is the context in which the template is evaluated.
-    # If it's a `Binding`, Haml uses it as the second argument to `Kernel#eval`;
-    # otherwise, Haml just uses its `#instance_eval` context.
-    #
-    # Note that Haml modifies the evaluation context
-    # (either the scope object or the `self` object of the scope binding).
-    # It extends {Haml::Helpers}, and various instance variables are set
-    # (all prefixed with `haml_`).
-    # For example:
-    #
-    #     s = "foobar"
-    #     Haml::Engine.new("%p= upcase").render(s) #=> "<p>FOOBAR</p>"
-    #
-    #     # s now extends Haml::Helpers
-    #     s.respond_to?(:html_attrs) #=> true
-    #
-    # `locals` is a hash of local variables to make available to the template.
-    # For example:
-    #
-    #     Haml::Engine.new("%p= foo").render(Object.new, :foo => "Hello, world!") #=> "<p>Hello, world!</p>"
-    #
-    # If a block is passed to render,
-    # that block is run when `yield` is called
-    # within the template.
-    #
-    # Due to some Ruby quirks,
-    # if `scope` is a `Binding` object and a block is given,
-    # the evaluation context may not be quite what the user expects.
-    # In particular, it's equivalent to passing `eval("self", scope)` as `scope`.
-    # This won't have an effect in most cases,
-    # but if you're relying on local variables defined in the context of `scope`,
-    # they won't work.
-    #
-    # @param scope [Binding, Object] The context in which the template is evaluated
-    # @param locals [{Symbol => Object}] Local variables that will be made available
-    #   to the template
-    # @param block [#to_proc] A block that can be yielded to within the template
-    # @return [String] The rendered template
-    def render(scope = Object.new, locals = {}, &block)
-      parent = scope.instance_variable_defined?(:@haml_buffer) ? scope.instance_variable_get(:@haml_buffer) : nil
-      buffer = Haml::Buffer.new(parent, @options.for_buffer)
-
-      if scope.is_a?(Binding)
-        scope_object = eval("self", scope)
-        scope = scope_object.instance_eval{binding} if block_given?
-      else
-        scope_object = scope
-        scope = scope_object.instance_eval{binding}
-      end
-
-      set_locals(locals.merge(:_hamlout => buffer, :_erbout => buffer.buffer), scope, scope_object)
-
-      scope_object.extend(Haml::Helpers)
-      scope_object.instance_variable_set(:@haml_buffer, buffer)
-      begin
-        eval(@temple_engine.precompiled_with_return_value, scope, @options.filename, @options.line)
-      rescue ::SyntaxError => e
-        raise SyntaxError, e.message
-      end
-    ensure
-      # Get rid of the current buffer
-      scope_object.instance_variable_set(:@haml_buffer, buffer.upper) if buffer
-    end
-    alias_method :to_html, :render
-
-    # Returns a proc that, when called,
-    # renders the template and returns the result as a string.
-    #
-    # `scope` works the same as it does for render.
-    #
-    # The first argument of the returned proc is a hash of local variable names to values.
-    # However, due to an unfortunate Ruby quirk,
-    # the local variables which can be assigned must be pre-declared.
-    # This is done with the `local_names` argument.
-    # For example:
-    #
-    #     # This works
-    #     Haml::Engine.new("%p= foo").render_proc(Object.new, :foo).call :foo => "Hello!"
-    #       #=> "<p>Hello!</p>"
-    #
-    #     # This doesn't
-    #     Haml::Engine.new("%p= foo").render_proc.call :foo => "Hello!"
-    #       #=> NameError: undefined local variable or method `foo'
-    #
-    # The proc doesn't take a block; any yields in the template will fail.
-    #
-    # @param scope [Binding, Object] The context in which the template is evaluated
-    # @param local_names [Array<Symbol>] The names of the locals that can be passed to the proc
-    # @return [Proc] The proc that will run the template
-    def render_proc(scope = Object.new, *local_names)
-      if scope.is_a?(Binding)
-        scope_object = eval("self", scope)
-      else
-        scope_object = scope
-        scope = scope_object.instance_eval{binding}
-      end
-
-      begin
-        str = @temple_engine.precompiled_with_ambles(local_names)
-        eval(
-          "Proc.new { |*_haml_locals| _haml_locals = _haml_locals[0] || {}; #{str}}\n",
-          scope,
-          @options.filename,
-          @options.line
-        )
-      rescue ::SyntaxError => e
-        raise SyntaxError, e.message
-      end
-    end
-
-    # Defines a method on `object` with the given name
-    # that renders the template and returns the result as a string.
-    #
-    # If `object` is a class or module,
-    # the method will instead be defined as an instance method.
-    # For example:
-    #
-    #     t = Time.now
-    #     Haml::Engine.new("%p\n  Today's date is\n  .date= self.to_s").def_method(t, :render)
-    #     t.render #=> "<p>\n  Today's date is\n  <div class='date'>Fri Nov 23 18:28:29 -0800 2007</div>\n</p>\n"
-    #
-    #     Haml::Engine.new(".upcased= upcase").def_method(String, :upcased_div)
-    #     "foobar".upcased_div #=> "<div class='upcased'>FOOBAR</div>\n"
-    #
-    # The first argument of the defined method is a hash of local variable names to values.
-    # However, due to an unfortunate Ruby quirk,
-    # the local variables which can be assigned must be pre-declared.
-    # This is done with the `local_names` argument.
-    # For example:
-    #
-    #     # This works
-    #     obj = Object.new
-    #     Haml::Engine.new("%p= foo").def_method(obj, :render, :foo)
-    #     obj.render(:foo => "Hello!") #=> "<p>Hello!</p>"
-    #
-    #     # This doesn't
-    #     obj = Object.new
-    #     Haml::Engine.new("%p= foo").def_method(obj, :render)
-    #     obj.render(:foo => "Hello!") #=> NameError: undefined local variable or method `foo'
-    #
-    # Note that Haml modifies the evaluation context
-    # (either the scope object or the `self` object of the scope binding).
-    # It extends {Haml::Helpers}, and various instance variables are set
-    # (all prefixed with `haml_`).
-    #
-    # @param object [Object, Module] The object on which to define the method
-    # @param name [String, Symbol] The name of the method to define
-    # @param local_names [Array<Symbol>] The names of the locals that can be passed to the proc
-    def def_method(object, name, *local_names)
-      method = object.is_a?(Module) ? :module_eval : :instance_eval
-
-      object.send(method, "def #{name}(_haml_locals = {}); #{@temple_engine.precompiled_with_ambles(local_names)}; end",
-                  @options.filename, @options.line)
-    end
-
-    private
-
-    def set_locals(locals, scope, scope_object)
-      scope_object.instance_variable_set :@_haml_locals, locals
-      set_locals = locals.keys.map { |k| "#{k} = @_haml_locals[#{k.inspect}]" }.join("\n")
-      eval(set_locals, scope)
-    end
-  end
-end

data/bundle/ruby/3.1.0/gems/haml-5.2.2/lib/haml/escapable.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module Haml
-  # Like Temple::Filters::Escapable, but with support for escaping by
-  # Haml::Herlpers.html_escape and Haml::Herlpers.escape_once.
-  class Escapable < Temple::Filter
-    # Special value of `flag` to ignore html_safe?
-    EscapeSafeBuffer = Struct.new(:value)
-
-    def initialize(*)
-      super
-      @escape = false
-      @escape_safe_buffer = false
-    end
-
-    def on_escape(flag, exp)
-      old_escape, old_escape_safe_buffer = @escape, @escape_safe_buffer
-      @escape_safe_buffer = flag.is_a?(EscapeSafeBuffer)
-      @escape = @escape_safe_buffer ? flag.value : flag
-      compile(exp)
-    ensure
-      @escape, @escape_safe_buffer = old_escape, old_escape_safe_buffer
-    end
-
-    # The same as Haml::AttributeBuilder.build_attributes
-    def on_static(value)
-      [:static,
-       if @escape == :once
-         escape_once(value)
-       elsif @escape
-         escape(value)
-       else
-         value
-       end
-      ]
-    end
-
-    # The same as Haml::AttributeBuilder.build_attributes
-    def on_dynamic(value)
-      [:dynamic,
-       if @escape == :once
-         escape_once_code(value)
-       elsif @escape
-         escape_code(value)
-       else
-         "(#{value}).to_s"
-       end
-      ]
-    end
-
-    private
-
-    def escape_once(value)
-      if @escape_safe_buffer
-        ::Haml::Helpers.escape_once_without_haml_xss(value)
-      else
-        ::Haml::Helpers.escape_once(value)
-      end
-    end
-
-    def escape(value)
-      if @escape_safe_buffer
-        ::Haml::Helpers.html_escape_without_haml_xss(value)
-      else
-        ::Haml::Helpers.html_escape(value)
-      end
-    end
-
-    def escape_once_code(value)
-      "::Haml::Helpers.escape_once#{('_without_haml_xss' if @escape_safe_buffer)}((#{value}))"
-    end
-
-    def escape_code(value)
-      "::Haml::Helpers.html_escape#{('_without_haml_xss' if @escape_safe_buffer)}((#{value}))"
-    end
-  end
-end

data/bundle/ruby/3.1.0/gems/haml-5.2.2/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