brakeman 7.0.2 → 7.1.1

data/bundle/ruby/3.1.0/gems/haml-6.4.0/lib/haml/attribute_compiler.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+require 'haml/attribute_builder'
+require 'haml/attribute_parser'
+require 'haml/ruby_expression'
+
+module Haml
+  # The list of boolean attributes. You may add custom attributes to this constant.
+  BOOLEAN_ATTRIBUTES = %w[disabled readonly multiple checked autobuffer
+                       autoplay controls loop selected hidden scoped async
+                       defer reversed ismap seamless muted required
+                       autofocus novalidate formnovalidate open pubdate
+                       itemscope allowfullscreen default inert sortable
+                       truespeed typemustmatch download]
+
+  class AttributeCompiler
+    def initialize(identity, options)
+      @identity = identity
+      @quote  = options[:attr_quote]
+      @format = options[:format]
+      @escape_attrs = options[:escape_attrs]
+    end
+
+    def compile(node)
+      hashes = []
+      if node.value[:object_ref] != :nil || !AttributeParser.available?
+        return runtime_compile(node)
+      end
+      [node.value[:dynamic_attributes].new, node.value[:dynamic_attributes].old].compact.each do |attribute_str|
+        hash = AttributeParser.parse(attribute_str)
+        return runtime_compile(node) if hash.nil? || hash.any? { |_key, value| value.empty? }
+        hashes << hash
+      end
+      static_compile(node.value[:attributes], hashes)
+    end
+
+    private
+
+    def runtime_compile(node)
+      attrs = []
+      attrs.unshift(node.value[:attributes].inspect) if node.value[:attributes] != {}
+
+      args = [@escape_attrs.inspect, "#{@quote.inspect}.freeze", @format.inspect, node.value[:object_ref]] + attrs
+      [:html, :attrs, [:dynamic, "::Haml::AttributeBuilder.build(#{args.join(', ')}, #{node.value[:dynamic_attributes].to_literal})"]]
+    end
+
+    def static_compile(static_hash, dynamic_hashes)
+      temple = [:html, :attrs]
+      keys = [*static_hash.keys, *dynamic_hashes.map(&:keys).flatten].uniq.sort
+      keys.each do |key|
+        values = [[:static, static_hash[key]], *dynamic_hashes.map { |h| [:dynamic, h[key]] }]
+        values.select! { |_, exp| exp != nil }
+
+        case key
+        when 'id'
+          compile_id!(temple, key, values)
+        when 'class'
+          compile_class!(temple, key, values)
+        when 'data', 'aria'
+          compile_data!(temple, key, values)
+        when *BOOLEAN_ATTRIBUTES, /\Adata-/, /\Aaria-/
+          compile_boolean!(temple, key, values)
+        else
+          compile_common!(temple, key, values)
+        end
+      end
+      temple
+    end
+
+    def compile_id!(temple, key, values)
+      build_code = attribute_builder(:id, values)
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:html, :attr, key, [:static, eval(build_code).to_s]]
+      else
+        temple << [:html, :attr, key, [:dynamic, build_code]]
+      end
+    end
+
+    def compile_class!(temple, key, values)
+      build_code = attribute_builder(:class, values)
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:html, :attr, key, [:static, eval(build_code).to_s]]
+      else
+        temple << [:html, :attr, key, [:dynamic, build_code]]
+      end
+    end
+
+    def compile_data!(temple, key, values)
+      args = [@escape_attrs.inspect, "#{@quote.inspect}.freeze", values.map { |v| literal_for(v) }]
+      build_code = "::Haml::AttributeBuilder.build_#{key}(#{args.join(', ')})"
+
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:static, eval(build_code).to_s]
+      else
+        temple << [:dynamic, build_code]
+      end
+    end
+
+    def compile_boolean!(temple, key, values)
+      exp = literal_for(values.last)
+
+      if values.last.first == :static || Temple::StaticAnalyzer.static?(exp)
+        value = eval(exp)
+        case value
+        when true then temple << [:html, :attr, key, @format == :xhtml ? [:static, key] : [:multi]]
+        when false, nil
+        else temple << [:html, :attr, key, [:fescape, @escape_attrs, [:static, value.to_s]]]
+        end
+      else
+        var = @identity.generate
+        temple << [
+          :case, "(#{var} = (#{exp}))",
+          ['true', [:html, :attr, key, @format == :xhtml ? [:static, key] : [:multi]]],
+          ['false, nil', [:multi]],
+          [:else, [:multi, [:static, " #{key}=#{@quote}"], [:fescape, @escape_attrs, [:dynamic, var]], [:static, @quote]]],
+        ]
+      end
+    end
+
+    def compile_common!(temple, key, values)
+      temple << [:html, :attr, key, [:fescape, @escape_attrs, values.last]]
+    end
+
+    def attribute_builder(type, values)
+      args = [@escape_attrs.inspect, *values.map { |v| literal_for(v) }]
+      "::Haml::AttributeBuilder.build_#{type}(#{args.join(', ')})"
+    end
+
+    def literal_for(value)
+      type, exp = value
+      type == :static ? "#{exp.inspect}.freeze" : exp
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/haml-6.4.0/lib/haml/attribute_parser.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+require 'haml/ruby_expression'
+
+module Haml
+  class AttributeParser
+    class ParseSkip < StandardError
+    end
+
+    # @return [TrueClass, FalseClass] - return true if AttributeParser.parse can be used.
+    def self.available?
+      # TruffleRuby doesn't have Ripper.lex
+      defined?(Ripper) && Ripper.respond_to?(:lex) && Temple::StaticAnalyzer.available?
+    end
+
+    def self.parse(text)
+      self.new.parse(text)
+    end
+
+    def parse(text)
+      exp = wrap_bracket(text)
+      return if Temple::StaticAnalyzer.syntax_error?(exp)
+
+      hash = {}
+      tokens = Ripper.lex(exp)[1..-2] || []
+      each_attr(tokens) do |attr_tokens|
+        key = parse_key!(attr_tokens)
+        hash[key] = attr_tokens.map { |t| t[2] }.join.strip
+      end
+      hash
+    rescue ParseSkip
+      nil
+    end
+
+    private
+
+    def wrap_bracket(text)
+      text = text.strip
+      return text if text[0] == '{'
+      "{#{text}}"
+    end
+
+    def parse_key!(tokens)
+      _, type, str = tokens.shift
+      case type
+      when :on_sp
+        parse_key!(tokens)
+      when :on_label
+        str.tr(':', '')
+      when :on_symbeg
+        _, _, key = tokens.shift
+        assert_type!(tokens.shift, :on_tstring_end) if str != ':'
+        skip_until_hash_rocket!(tokens)
+        key
+      when :on_tstring_beg
+        _, _, key = tokens.shift
+        next_token = tokens.shift
+        unless next_token[1] == :on_label_end
+          assert_type!(next_token, :on_tstring_end)
+          skip_until_hash_rocket!(tokens)
+        end
+        key
+      else
+        raise ParseSkip
+      end
+    end
+
+    def assert_type!(token, type)
+      raise ParseSkip if token[1] != type
+    end
+
+    def skip_until_hash_rocket!(tokens)
+      until tokens.empty?
+        _, type, str = tokens.shift
+        break if type == :on_op && str == '=>'
+      end
+    end
+
+    def each_attr(tokens)
+      attr_tokens = []
+      open_tokens = Hash.new { |h, k| h[k] = 0 }
+
+      tokens.each do |token|
+        _, type, _ = token
+        case type
+        when :on_comma
+          if open_tokens.values.all?(&:zero?)
+            yield(attr_tokens)
+            attr_tokens = []
+            next
+          end
+        when :on_lbracket
+          open_tokens[:array] += 1
+        when :on_rbracket
+          open_tokens[:array] -= 1
+        when :on_lbrace
+          open_tokens[:block] += 1
+        when :on_rbrace
+          open_tokens[:block] -= 1
+        when :on_lparen
+          open_tokens[:paren] += 1
+        when :on_rparen
+          open_tokens[:paren] -= 1
+        when :on_embexpr_beg
+          open_tokens[:embexpr] += 1
+        when :on_embexpr_end
+          open_tokens[:embexpr] -= 1
+        when :on_sp
+          next if attr_tokens.empty?
+        end
+
+        attr_tokens << token
+      end
+      yield(attr_tokens) unless attr_tokens.empty?
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/haml-6.4.0/lib/haml/cli.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+require 'haml'
+require 'thor'
+
+module Haml
+  class CLI < Thor
+    class_option :escape_html, type: :boolean, default: true
+    class_option :escape_attrs, type: :boolean, default: true
+
+    desc 'render HAML', 'Render haml template'
+    option :load_path, type: :string, aliases: %w[-I]
+    option :require, type: :string, aliases: %w[-r]
+    def render(file)
+      process_load_options
+      code = generate_code(file)
+      puts eval(code, binding, file)
+    end
+
+    desc 'compile HAML', 'Show compile result'
+    option :actionview, type: :boolean, default: false, aliases: %w[-a]
+    option :color, type: :boolean, default: true
+    option :check, type: :boolean, default: false, aliases: %w[-c]
+    def compile(file)
+      code = generate_code(file)
+      if options[:check]
+        if error = validate_ruby(code, file)
+          abort error.message.split("\n").first
+        end
+        puts "Syntax OK"
+        return
+      end
+      puts_code(code, color: options[:color])
+    end
+
+    desc 'temple HAML', 'Show temple intermediate expression'
+    option :color, type: :boolean, default: true
+    def temple(file)
+      pp_object(generate_temple(file), color: options[:color])
+    end
+
+    desc 'parse HAML', 'Show parse result'
+    option :color, type: :boolean, default: true
+    def parse(file)
+      pp_object(generate_ast(file), color: options[:color])
+    end
+
+    desc 'version', 'Show the used haml version'
+    def version
+      puts Haml::VERSION
+    end
+
+    private
+
+    def process_load_options
+      if options[:load_path]
+        options[:load_path].split(':').each do |dir|
+          $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
+        end
+      end
+
+      if options[:require]
+        require options[:require]
+      end
+    end
+
+    def read_file(file)
+      if file == '-'
+        STDIN.read
+      else
+        File.read(file)
+      end
+    end
+
+    def generate_code(file)
+      template = read_file(file)
+      if options[:actionview]
+        require 'action_view'
+        require 'action_view/base'
+        require 'haml/rails_template'
+        handler = Haml::RailsTemplate.new
+        template = ActionView::Template.new(template, 'inline template', handler, { locals: [] })
+        code = handler.call(template)
+        <<-end_src
+          def _inline_template___2144273726781623612_70327218547300(local_assigns, output_buffer)
+            _old_virtual_path, @virtual_path = @virtual_path, nil;_old_output_buffer = @output_buffer;;#{code}
+          ensure
+            @virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
+          end
+        end_src
+      else
+        Haml::Engine.new(engine_options).call(template)
+      end
+    end
+
+    def generate_ast(file)
+      template = read_file(file)
+      Haml::Parser.new(engine_options).call(template)
+    end
+
+    def generate_temple(file)
+      ast = generate_ast(file)
+      Haml::Compiler.new(engine_options).call(ast)
+    end
+
+    def engine_options
+      Haml::Engine.options.to_h.merge(
+        escape_attrs: options[:escape_attrs],
+        escape_html:  options[:escape_html],
+      )
+    end
+
+    # Flexible default_task, compatible with haml's CLI
+    def method_missing(*args)
+      return super(*args) if args.length > 1
+      render(args.first.to_s)
+    end
+
+    def puts_code(code, color: true)
+      begin
+        require 'irb/color'
+      rescue LoadError
+        color = false
+      end
+      if color
+        puts IRB::Color.colorize_code(code)
+      else
+        puts code
+      end
+    end
+
+    # Enable colored pretty printing only for development environment.
+    def pp_object(arg, color: true)
+      begin
+        require 'irb/color_printer'
+      rescue LoadError
+        color = false
+      end
+      if color
+        IRB::ColorPrinter.pp(arg)
+      else
+        require 'pp'
+        pp(arg)
+      end
+    end
+
+    def validate_ruby(code, file)
+      begin
+        eval("BEGIN {return nil}; #{code}", binding, file)
+      rescue ::SyntaxError # Not to be confused with Haml::SyntaxError
+        $!
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/haml-6.4.0/lib/haml/compiler/children_compiler.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+require 'haml/temple_line_counter'
+
+module Haml
+  class Compiler
+    class ChildrenCompiler
+      def initialize
+        @lineno = 1
+        @multi_flattener = Temple::Filters::MultiFlattener.new
+      end
+
+      def compile(node, &block)
+        temple = [:multi]
+        return temple if node.children.empty?
+
+        temple << [:whitespace] if prepend_whitespace?(node)
+        node.children.each do |n|
+          rstrip_whitespace!(temple) if nuke_prev_whitespace?(n)
+          insert_newlines!(temple, n)
+          temple << moving_lineno(n) { block.call(n) }
+          temple << [:whitespace] if insert_whitespace?(n)
+        end
+        rstrip_whitespace!(temple) if nuke_inner_whitespace?(node)
+        temple
+      end
+
+      private
+
+      def insert_newlines!(temple, node)
+        (node.line - @lineno).times do
+          temple << [:newline]
+        end
+
+        @lineno = node.line
+      end
+
+      def moving_lineno(node, &block)
+        # before: As they may have children, we need to increment lineno before compilation.
+        case node.type
+        when :script, :silent_script
+          @lineno += 1
+        when :tag
+          [node.value[:dynamic_attributes].new, node.value[:dynamic_attributes].old].compact.each do |attribute_hash|
+            @lineno += attribute_hash.count("\n")
+          end
+          @lineno += 1 if node.children.empty? && node.value[:parse]
+        end
+
+        temple = block.call # compile
+
+        # after: filter may not have children, and for some dynamic filters we can't predict the number of lines.
+        case node.type
+        when :filter
+          @lineno += TempleLineCounter.count_lines(temple)
+        end
+
+        temple
+      end
+
+      def prepend_whitespace?(node)
+        return false unless %i[comment tag].include?(node.type)
+        !nuke_inner_whitespace?(node)
+      end
+
+      def nuke_inner_whitespace?(node)
+        case
+        when node.type == :tag
+          node.value[:nuke_inner_whitespace]
+        when node.parent.nil?
+          false
+        else
+          nuke_inner_whitespace?(node.parent)
+        end
+      end
+
+      def nuke_prev_whitespace?(node)
+        case node.type
+        when :tag
+          node.value[:nuke_outer_whitespace]
+        when :silent_script
+          !node.children.empty? && nuke_prev_whitespace?(node.children.first)
+        else
+          false
+        end
+      end
+
+      def nuke_outer_whitespace?(node)
+        return false if node.type != :tag
+        node.value[:nuke_outer_whitespace]
+      end
+
+      def rstrip_whitespace!(temple)
+        return if temple.size == 1
+
+        case temple[0]
+        when :multi
+          case temple[-1][0]
+          when :whitespace
+            temple.delete_at(-1)
+          when :multi, :block
+            rstrip_whitespace!(temple[-1])
+          end
+        when :block
+          _block, code, exp = temple
+          if code.start_with?(/\s*if\s/)
+            # Remove [:whitespace] before `end`
+            exp.replace(@multi_flattener.call(exp))
+            rstrip_whitespace!(exp)
+
+            # Remove [:whitespace] before `else` if exists
+            else_index = find_else_index(exp)
+            if else_index
+              whitespace_index = else_index - 1
+              while exp[whitespace_index] == [:newline]
+                whitespace_index -= 1
+              end
+              if exp[whitespace_index] == [:whitespace]
+                exp.delete_at(whitespace_index)
+              end
+            end
+          end
+        end
+      end
+
+      def find_else_index(temple)
+        multi, *args = temple
+        return nil if multi != :multi
+
+        args.each_with_index do |arg, index|
+          if arg[0] == :code && arg[1].match?(/\A\s*else\s*\z/)
+            return index + 1
+          end
+        end
+        nil
+      end
+
+      def insert_whitespace?(node)
+        return false if nuke_outer_whitespace?(node)
+
+        case node.type
+        when :doctype
+          node.value[:type] != 'xml'
+        when :comment, :plain, :tag
+          true
+        when :script
+          node.children.empty? && !nuke_inner_whitespace?(node)
+        when :filter
+          !%w[ruby].include?(node.value[:name])
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/haml-6.4.0/lib/haml/compiler/comment_compiler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module Haml
+  class Compiler
+    class CommentCompiler
+      def compile(node, &block)
+        if node.value[:conditional]
+          compile_conditional_comment(node, &block)
+        else
+          compile_html_comment(node, &block)
+        end
+      end
+
+      private
+
+      def compile_html_comment(node, &block)
+        if node.children.empty?
+          [:html, :comment, compile_text(node)]
+        else
+          [:html, :comment, yield(node)]
+        end
+      end
+
+      def compile_conditional_comment(node, &block)
+        condition = node.value[:conditional]
+        if node.value[:conditional] =~ /\A\[(\[*[^\[\]]+\]*)\]/
+          condition = $1
+        end
+
+        content =
+          if node.children.empty?
+            compile_text(node)
+          else
+            yield(node)
+          end
+        [:html, :condcomment, condition, content, node.value[:revealed]]
+      end
+
+      def compile_text(node)
+        text =
+          if node.value[:parse]
+            # Just always escaping the result for safety. We could respect
+            # escape_html, but I don't see any use case for it.
+            [:escape, true, [:dynamic, node.value[:text]]]
+          else
+            [:static, node.value[:text]]
+          end
+        [:multi, [:static, ' '], text, [:static, ' ']]
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/haml-6.4.0/lib/haml/compiler/doctype_compiler.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module Haml
+  class Compiler
+    class DoctypeCompiler
+      def initialize(options = {})
+        @format = options[:format]
+      end
+
+      def compile(node)
+        case node.value[:type]
+        when ''
+          html_doctype(node)
+        when 'xml'
+          xml_doctype
+        when 'rdfa'
+          rdfa_doctype
+        else
+          [:html, :doctype, node.value[:type]]
+        end
+      end
+
+      private
+
+      def html_doctype(node)
+        version = node.value[:version] || :transitional
+        case @format
+        when :xhtml
+          [:html, :doctype, version]
+        when :html4
+          [:html, :doctype, :transitional]
+        when :html5
+          [:html, :doctype, :html]
+        else
+          [:html, :doctype, @format]
+        end
+      end
+
+      def xml_doctype
+        case @format
+        when :xhtml
+          [:static, "<?xml version='1.0' encoding='utf-8' ?>\n"]
+        else
+          [:multi]
+        end
+      end
+
+      def rdfa_doctype
+        [:static, '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">']
+      end
+    end
+  end
+end