brakeman 5.2.2 → 7.1.1

data/bundle/ruby/3.1.0/gems/slim-5.2.1/lib/slim/smart/parser.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module Slim
+  module Smart
+    # @api private
+    class Parser < ::Slim::Parser
+      define_options implicit_text: true
+
+      def initialize(opts = {})
+        super
+        word_re = options[:implicit_text] ? '[_a-z0-9]' : '\p{Word}'
+        attr_keys = Regexp.union(@attr_shortcut.keys.sort_by { |k| -k.size })
+        @attr_shortcut_re = /\A(#{attr_keys}+)((?:\p{Word}|-)*)/
+        tag_keys = Regexp.union((@tag_shortcut.keys - @attr_shortcut.keys).sort_by { |k| -k.size })
+        @tag_re = /\A(?:#{attr_keys}(?=-*\p{Word})|#{tag_keys}|\*(?=[^\s]+)|(#{word_re}(?:#{word_re}|:|-)*#{word_re}|#{word_re}+))/
+      end
+
+      def unknown_line_indicator
+        if @line =~ /\A>( ?)/
+          # Found explicit text block.
+          @stacks.last << [:slim, :text, :explicit, parse_text_block($', @indents.last + $1.size + 1)]
+        else
+          unless options[:implicit_text]
+            syntax_error! 'Illegal shortcut' if @line =~ @attr_shortcut_re
+            super
+          end
+          # Found implicit smart text block.
+          if line = @lines.first
+            indent = (line =~ /\A\s*\Z/ ? @indents.last + 1 : get_indent(line))
+          end
+          @stacks.last << [:slim, :text, :implicit, parse_text_block(@line, indent)]
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/slim-5.2.1/lib/slim/smart.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+require 'slim'
+require 'slim/smart/filter'
+require 'slim/smart/escaper'
+require 'slim/smart/parser'
+
+Slim::Engine.replace Slim::Parser, Slim::Smart::Parser
+Slim::Engine.after Slim::Smart::Parser, Slim::Smart::Filter
+Slim::Engine.after Slim::Interpolation, Slim::Smart::Escaper

data/bundle/ruby/3.1.0/gems/slim-5.2.1/lib/slim/splat/builder.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+module Slim
+  class InvalidAttributeNameError < StandardError; end
+  module Splat
+    # @api private
+    class Builder
+      # https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
+      INVALID_ATTRIBUTE_NAME_REGEX = /[ \0"'>\/=]/
+
+      def initialize(options)
+        @options = options
+        @attrs = {}
+      end
+
+      def code_attr(name, escape, value)
+        if delim = @options[:merge_attrs][name]
+          value = Array === value ? value.join(delim) : value.to_s
+          attr(name, escape_html(escape, value)) unless value.empty?
+        elsif @options[:hyphen_attrs].include?(name) && Hash === value
+          hyphen_attr(name, escape, value)
+        elsif value != false && value != nil
+          attr(name, escape_html(escape, value))
+        end
+      end
+
+      def splat_attrs(splat)
+        splat.each do |name, value|
+          code_attr(name.to_s, true, value)
+        end
+      end
+
+      def attr(name, value)
+        if name =~ INVALID_ATTRIBUTE_NAME_REGEX
+          raise InvalidAttributeNameError, "Invalid attribute name '#{name}' was rendered"
+        end
+        if @attrs[name]
+          if delim = @options[:merge_attrs][name]
+            @attrs[name] = @attrs[name].to_s + delim + value.to_s
+          else
+            raise("Multiple #{name} attributes specified")
+          end
+        else
+          @attrs[name] = value
+        end
+      end
+
+      def build_tag(&block)
+        tag = @attrs.delete('tag').to_s
+        tag = @options[:default_tag] if tag.empty?
+        if block
+          # This is a bit of a hack to get a universal capturing.
+          #
+          # TODO: Add this as a helper somewhere to solve these capturing issues
+          # once and for all.
+          #
+          # If we have Slim capturing disabled and the scope defines the method `capture` (i.e. Rails)
+          # we use this method to capture the content.
+          #
+          # otherwise we just use normal Slim capturing (yield).
+          #
+          # See https://github.com/slim-template/slim/issues/591
+          #     https://github.com/slim-template/slim#helpers-capturing-and-includes
+          #
+          content =
+            if @options[:disable_capture] && (scope = block.binding.eval('self')).respond_to?(:capture)
+              scope.capture(&block)
+            else
+              yield
+            end
+          "<#{tag}#{build_attrs}>#{content}</#{tag}>"
+        else
+          "<#{tag}#{build_attrs} />"
+        end
+      end
+
+      def build_attrs
+        attrs = @options[:sort_attrs] ? @attrs.sort_by(&:first) : @attrs
+        attrs.map do |k, v|
+          if v == true
+            if @options[:format] == :xhtml
+              " #{k}=#{@options[:attr_quote]}#{@options[:attr_quote]}"
+            else
+              " #{k}"
+            end
+          else
+            " #{k}=#{@options[:attr_quote]}#{v}#{@options[:attr_quote]}"
+          end
+        end.join
+      end
+
+      private
+
+      def hyphen_attr(name, escape, value)
+        if Hash === value
+          if @options[:hyphen_underscore_attrs]
+            value.each do |n, v|
+              hyphen_attr("#{name}-#{n.to_s.tr('_', '-')}", escape, v)
+            end
+          else
+            value.each do |n, v|
+              hyphen_attr("#{name}-#{n}", escape, v)
+            end
+          end
+        else
+          attr(name, escape_html(escape, value))
+        end
+      end
+
+      def escape_html(escape, value)
+        return value if !escape || value == true
+        @options[:use_html_safe] ? Temple::Utils.escape_html_safe(value) : Temple::Utils.escape_html(value)
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/slim-5.2.1/lib/slim/splat/filter.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+module Slim
+  module Splat
+    # @api private
+    class Filter < ::Slim::Filter
+      define_options :merge_attrs, :attr_quote, :sort_attrs, :default_tag, :format, :disable_capture,
+                     hyphen_attrs: %w(data aria), use_html_safe: ''.respond_to?(:html_safe?),
+                     hyphen_underscore_attrs: false
+
+      def call(exp)
+        @splat_options = nil
+        exp = compile(exp)
+        if @splat_options
+          opts = options.to_hash.reject { |k, v| !Filter.options.valid_key?(k) }.inspect
+          [:multi, [:code, "#{@splat_options} = #{opts}"], exp]
+        else
+          exp
+        end
+      end
+
+      # Handle tag expression `[:html, :tag, name, attrs, content]`
+      #
+      # @param [String] name Tag name
+      # @param [Array] attrs Temple expression
+      # @param [Array] content Temple expression
+      # @return [Array] Compiled temple expression
+      def on_html_tag(name, attrs, content = nil)
+        return super if name != '*'
+        builder, block = make_builder(attrs[2..-1])
+        if content
+          [:multi,
+           block,
+           [:slim, :output, false,
+            "#{builder}.build_tag #{empty_exp?(content) ? '{}' : 'do'}",
+            compile(content)]]
+        else
+          [:multi,
+           block,
+           [:dynamic, "#{builder}.build_tag"]]
+        end
+      end
+
+      # Handle attributes expression `[:html, :attrs, *attrs]`
+      #
+      # @param [Array] attrs Array of temple expressions
+      # @return [Array] Compiled temple expression
+      def on_html_attrs(*attrs)
+        if attrs.any? { |attr| splat?(attr) }
+          builder, block = make_builder(attrs)
+          [:multi,
+           block,
+           [:dynamic, "#{builder}.build_attrs"]]
+        else
+          super
+        end
+      end
+
+      protected
+
+      def splat?(attr)
+        # Splat attribute given
+        attr[0] == :slim && attr[1] == :splat ||
+          # Hyphenated attribute also needs splat handling
+          (attr[0] == :html && attr[1] == :attr && options[:hyphen_attrs].include?(attr[2]) &&
+           attr[3][0] == :slim && attr[3][1] == :attrvalue)
+      end
+
+      def make_builder(attrs)
+        @splat_options ||= unique_name
+        builder = unique_name
+        result = [:multi, [:code, "#{builder} = ::Slim::Splat::Builder.new(#{@splat_options})"]]
+        attrs.each do |attr|
+          result <<
+            if attr[0] == :html && attr[1] == :attr
+              if attr[3][0] == :slim && attr[3][1] == :attrvalue
+                [:code, "#{builder}.code_attr(#{attr[2].inspect}, #{attr[3][2]}, (#{attr[3][3]}))"]
+              else
+                tmp = unique_name
+                [:multi,
+                 [:capture, tmp, compile(attr[3])],
+                 [:code, "#{builder}.attr(#{attr[2].inspect}, #{tmp})"]]
+              end
+            elsif attr[0] == :slim && attr[1] == :splat
+              [:code, "#{builder}.splat_attrs((#{attr[2]}))"]
+            else
+              attr
+            end
+        end
+        [builder, result]
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/slim-5.2.1/lib/slim/template.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Slim
+  # Tilt template implementation for Slim
+  # @api public
+  Template = Temple::Templates::Tilt(Slim::Engine, register_as: :slim)
+end

data/bundle/ruby/3.1.0/gems/slim-5.2.1/lib/slim/translator.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+require 'slim'
+
+module Slim
+  # @api private
+  class Translator < Filter
+    define_options :tr,
+                   tr_mode: :dynamic,
+                   tr_fn: '_'
+
+    if defined?(::I18n)
+      set_options tr_fn: '::Slim::Translator.i18n_text',
+                  tr: true
+    elsif defined?(::GetText)
+      set_options tr_fn: '::GetText._',
+                  tr: true
+    elsif defined?(::FastGettext)
+      set_options tr_fn: '::FastGettext::Translation._',
+                  tr: true
+    end
+
+    def self.i18n_text(text)
+      I18n.t!(text)
+    rescue I18n::MissingTranslationData
+      text
+    end
+
+    def self.i18n_key(text)
+      key = text.parameterize.underscore
+      I18n.t!(key)
+    rescue I18n::MissingTranslationData
+      text
+    end
+
+    def call(exp)
+      options[:tr] ? super : exp
+    end
+
+    def initialize(opts = {})
+      super
+      case options[:tr_mode]
+      when :static
+        @translator = StaticTranslator.new(tr_fn: options[:tr_fn])
+      when :dynamic
+        @translator = DynamicTranslator.new(tr_fn: options[:tr_fn])
+      else
+        raise ArgumentError, "Invalid translator mode #{options[:tr_mode].inspect}"
+      end
+    end
+
+    def on_slim_text(type, exp)
+      [:slim, :text, type, @translator.call(exp)]
+    end
+
+    private
+
+    class StaticTranslator < Filter
+      define_options :tr_fn
+
+      def initialize(opts = {})
+        super
+        @translate = eval("proc {|string| #{options[:tr_fn]}(string) }")
+      end
+
+      def call(exp)
+        @text, @captures = ''.dup, []
+        result = compile(exp)
+
+        text = @translate.call(@text)
+        while text =~ /%(\d+)/
+          result << [:static, $`] << @captures[$1.to_i - 1]
+          text = $'
+        end
+        result << [:static, text]
+      end
+
+      def on_static(text)
+        @text << text
+        [:multi]
+      end
+
+      def on_slim_output(escape, code, content)
+        @captures << [:slim, :output, escape, code, content]
+        @text << "%#{@captures.size}"
+        [:multi]
+      end
+    end
+
+    class DynamicTranslator < Filter
+      define_options :tr_fn
+
+      def call(exp)
+        @captures_count, @captures_var, @text = 0, unique_name, ''.dup
+
+        result = compile(exp)
+
+        if @captures_count > 0
+          result.insert(1, [:code, "#{@captures_var}=[]"])
+          result << [:slim, :output, false, "#{options[:tr_fn]}(#{@text.inspect}).gsub(/%(\\d+)/) { #{@captures_var}[$1.to_i-1] }", [:multi]]
+        else
+          result << [:slim, :output, false, "#{options[:tr_fn]}(#{@text.inspect})", [:multi]]
+        end
+      end
+
+      def on_static(text)
+        @text << text
+        [:multi]
+      end
+
+      def on_slim_output(escape, code, content)
+        @captures_count += 1
+        @text << "%#{@captures_count}"
+        [:capture, "#{@captures_var}[#{@captures_count - 1}]", [:slim, :output, escape, code, content]]
+      end
+    end
+  end
+end
+
+Slim::Engine.before Slim::EndInserter, Slim::Translator

data/bundle/ruby/3.1.0/gems/slim-5.2.1/lib/slim/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Slim
+  # Slim version string
+  # @api public
+  VERSION = '5.2.1'
+end

data/bundle/ruby/3.1.0/gems/slim-5.2.1/lib/slim.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require 'temple'
+require 'slim/parser'
+require 'slim/filter'
+require 'slim/do_inserter'
+require 'slim/end_inserter'
+require 'slim/embedded'
+require 'slim/interpolation'
+require 'slim/controls'
+require 'slim/splat/filter'
+require 'slim/splat/builder'
+require 'slim/code_attributes'
+require 'slim/engine'
+require 'slim/template'
+require 'slim/version'
+require 'slim/railtie' if defined?(Rails::Railtie)

data/bundle/ruby/3.1.0/gems/slim-5.2.1/slim.gemspec

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/lib/slim/version'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name              = 'slim'
+  s.version           = Slim::VERSION
+  s.date              = Date.today.to_s
+  s.authors           = ['Daniel Mendler', 'Andrew Stone', 'Fred Wu']
+  s.email             = ['mail@daniel-mendler.de', 'andy@stonean.com', 'ifredwu@gmail.com']
+  s.summary           = 'Slim is a template language.'
+  s.description       = 'Slim is a template language whose goal is reduce the syntax to the essential parts without becoming cryptic.'
+  s.homepage          = 'https://slim-template.github.io/'
+  s.license           = 'MIT'
+
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/slim-template/slim/issues",
+    "changelog_uri"     => "https://github.com/slim-template/slim/blob/main/CHANGES",
+    "documentation_uri" => "https://rubydoc.info/gems/slim/frames",
+    "homepage_uri"      => "https://slim-template.github.io/",
+    "source_code_uri"   => "https://github.com/slim-template/slim",
+    "wiki_uri"          => "https://github.com/slim-template/slim/wiki",
+    "funding_uri"       => "https://github.com/sponsors/slim-template"
+  }
+
+  s.files             = `git ls-files`.split("\n")
+  s.executables       = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths     = %w(lib)
+
+  s.required_ruby_version = '>= 2.5.0'
+
+  s.add_runtime_dependency('temple', ['~> 0.10.0'])
+  s.add_runtime_dependency('tilt', ['>= 2.1.0'])
+end