brakeman 7.1.2 → 8.0.6

data/bundle/ruby/3.2.0/gems/{slim-5.2.1 → slim-5.2.2}/lib/slim/embedded.rb

@@ -228,13 +228,13 @@ module Slim
     end
 
     # These engines are executed at compile time, embedded ruby is interpolated
+    register :asciidoc,   InterpolateTiltEngine
     register :markdown,   InterpolateTiltEngine
     register :textile,    InterpolateTiltEngine
     register :rdoc,       InterpolateTiltEngine
 
     # These engines are executed at compile time
     register :coffee,     JavaScriptEngine,                engine: TiltEngine
-    register :less,       TagEngine,          tag: :style, engine: TiltEngine
     register :sass,       TagEngine, :pretty, tag: :style, engine: SassEngine
     register :scss,       TagEngine, :pretty, tag: :style, engine: SassEngine
 

data/bundle/ruby/3.2.0/gems/{slim-5.2.1 → slim-5.2.2}/lib/slim/logic_less/context.rb

@@ -27,7 +27,8 @@ module Slim
       end
 
       def section(name)
-        if dict = scope[name]
+        dict = scope[name]
+        if dict && !(dict.respond_to?(:empty?) && dict.empty?)
           if !dict.respond_to?(:has_key?) && dict.respond_to?(:each)
             new_scope do
               dict.each do |d|
@@ -42,8 +43,8 @@ module Slim
       end
 
       def inverted_section(name)
-        value = scope[name]
-        yield if !value || (value.respond_to?(:empty?) && value.empty?)
+        dict = scope[name]
+        yield if !dict || (dict.respond_to?(:empty?) && dict.empty?)
       end
 
       def to_s

data/bundle/ruby/3.2.0/gems/{slim-5.2.1 → slim-5.2.2}/lib/slim/splat/builder.rb

@@ -48,25 +48,7 @@ module Slim
         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
+          content = capture_block_content(&block)
           "<#{tag}#{build_attrs}>#{content}</#{tag}>"
         else
           "<#{tag}#{build_attrs} />"
@@ -90,6 +72,23 @@ module Slim
 
       private
 
+      # Captures block content using the appropriate capturing mechanism.
+      #
+      # 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
+      def capture_block_content(&block)
+        if @options[:disable_capture] && (scope = block.binding.eval('self')).respond_to?(:capture)
+          scope.capture(&block)
+        else
+          yield
+        end
+      end
+
       def hyphen_attr(name, escape, value)
         if Hash === value
           if @options[:hyphen_underscore_attrs]

data/bundle/ruby/3.2.0/gems/{slim-5.2.1 → slim-5.2.2}/lib/slim/version.rb

@@ -2,5 +2,5 @@
 module Slim
   # Slim version string
   # @api public
-  VERSION = '5.2.1'
+  VERSION = '5.2.2'
 end

data/bundle/ruby/3.2.0/gems/{temple-0.10.4 → temple-0.10.6}/CHANGES

@@ -1,3 +1,11 @@
+0.10.6
+
+  * Make StaticAnalyzer recognize shorthand syntax as dynamic (#149)
+
+0.10.5
+
+  * Allow using prism as the parser engine (#156)
+
 0.10.4
 
   * Fix Ruby 3.4 compatibility (#152)

data/bundle/ruby/3.2.0/gems/{temple-0.10.4 → temple-0.10.6}/README.md

@@ -1,7 +1,7 @@
 Temple
 ======
 
-[![test](https://github.com/judofyr/temple/actions/workflows/test.yml/badge.svg)](https://github.com/judofyr/temple/actions/workflows/test.yml) [![Code Climate](https://codeclimate.com/github/judofyr/temple.svg)](https://codeclimate.com/github/judofyr/temple) [![Gem Version](https://badge.fury.io/rb/temple.svg)](https://rubygems.org/gems/temple) [![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/gems/temple/frames)
+[![test](https://github.com/judofyr/temple/actions/workflows/test.yml/badge.svg)](https://github.com/judofyr/temple/actions/workflows/test.yml) [![Maintainability](https://qlty.sh/gh/judofyr/projects/temple/maintainability.svg)](https://qlty.sh/gh/judofyr/projects/temple) [![Gem Version](https://badge.fury.io/rb/temple.svg)](https://rubygems.org/gems/temple) [![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/gems/temple/frames)
 
 Temple is an abstraction and a framework for compiling templates to pure Ruby.
 It's all about making it easier to experiment, implement and optimize template

data/bundle/ruby/3.2.0/gems/{temple-0.10.4 → temple-0.10.6}/lib/temple/filters/static_analyzer.rb

@@ -4,7 +4,7 @@ module Temple
     # Convert [:dynamic, code] to [:static, text] if code is static Ruby expression.
     class StaticAnalyzer < Filter
       def call(exp)
-        # Optimize only when Ripper is available.
+        # Optimize only when a parser engine is available.
         if ::Temple::StaticAnalyzer.available?
           super
         else

data/bundle/ruby/3.2.0/gems/{temple-0.10.4 → temple-0.10.6}/lib/temple/filters/string_splitter.rb

@@ -1,14 +1,70 @@
 # frozen_string_literal: true
-begin
-  require 'ripper'
-rescue LoadError
-end
+require 'temple/parser_engine'
 
 module Temple
   module Filters
     # Compile [:dynamic, "foo#{bar}"] to [:multi, [:static, 'foo'], [:dynamic, 'bar']]
     class StringSplitter < Filter
-      if defined?(Ripper) && Ripper.respond_to?(:lex)
+      if PARSER_ENGINE == :prism
+        class << self
+          # `code` param must be valid string literal
+          def compile(code)
+            compiled = try_compile(code)
+            raise(FilterError, "Expected string literal") unless compiled
+            compiled
+          end
+
+          def try_compile(code)
+            result = Prism.parse(code)
+            return unless result.success?
+
+            stmts = result.value.statements.body
+            return if stmts.size != 1
+
+            stack = [stmts.first]
+            compiled = []
+
+            until stack.empty?
+              case (node = stack.pop).type
+              when :interpolated_string_node
+                stack.concat(node.parts.reverse)
+              when :string_node
+                if !(unescaped = node.unescaped).empty?
+                  compiled << [:static, unescaped]
+                end
+              when :embedded_statements_node
+                if (stmts = node.statements) && !(slice = stmts.slice).empty?
+                  compiled << [:dynamic, slice]
+                end
+              when :embedded_variable_node
+                compiled << [:dynamic, node.variable.slice]
+              else
+                return
+              end
+            end
+
+            compiled
+          end
+        end
+
+        def on_dynamic(code)
+          return [:dynamic, code] if code.include?("\n")
+
+          compiled = StringSplitter.try_compile(code)
+          return [:dynamic, code] unless compiled
+
+          temple = [:multi]
+          compiled.each do |type, content|
+            case type
+            when :static
+              temple << [:static, content]
+            when :dynamic
+              temple << on_dynamic(content)
+            end
+          end
+          temple
+        end
+      elsif PARSER_ENGINE == :ripper
         class << self
           # `code` param must be valid string literal
           def compile(code)

data/bundle/ruby/3.2.0/gems/temple-0.10.6/lib/temple/parser_engine.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Temple
+  temple_parser_engine = ENV['TEMPLE_PARSER_ENGINE']
+
+  prism_available =
+    if !temple_parser_engine || temple_parser_engine == 'prism'
+      begin
+        require 'prism'
+        true
+      rescue LoadError
+      end
+    end
+
+  ripper_available =
+    if !temple_parser_engine || temple_parser_engine == 'ripper'
+      begin
+        require 'ripper'
+        Ripper.respond_to?(:lex)
+      rescue LoadError
+      end
+    end
+
+  PARSER_ENGINE =
+    if prism_available
+      :prism
+    elsif ripper_available
+      :ripper
+    else
+      :none
+    end
+
+  private_constant :PARSER_ENGINE
+end

data/bundle/ruby/3.2.0/gems/temple-0.10.6/lib/temple/static_analyzer.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+require 'temple/parser_engine'
+
+module Temple
+  module StaticAnalyzer
+    if PARSER_ENGINE == :prism
+      class << self
+        def available?
+          true
+        end
+
+        def static?(code)
+          return false if code.nil? || code.strip.empty?
+          (result = Prism.parse(code)).success? && static_node?(result.value)
+        end
+
+        def syntax_error?(code)
+          !Prism.parse_success?(code)
+        end
+
+        private
+
+        def static_node?(node)
+          case node.type
+          when :program_node
+            static_node?(node.statements)
+          when :parentheses_node
+            (stmts = node.body).is_a?(Prism::StatementsNode) &&
+              static_node?(stmts)
+          when :statements_node
+            node.body.size == 1 && static_node?(node.body.first)
+          when :interpolated_string_node
+            node.parts.all? { |part| static_node?(part) }
+          when :embedded_statements_node
+            (stmts = node.statements) && static_node?(stmts)
+          when :array_node
+            node.elements.all? { |elem| static_node?(elem) }
+          when :hash_node, :keyword_hash_node
+            node.elements.all? { |elem| static_node?(elem) }
+          when :assoc_node
+            static_node?(node.key) && static_node?(node.value)
+          when :string_node, :integer_node, :float_node, :imaginary_node,
+               :rational_node, :symbol_node, :true_node, :false_node, :nil_node
+            true
+          else
+            false
+          end
+        end
+      end
+    elsif PARSER_ENGINE == :ripper
+      STATIC_TOKENS = [
+        :on_tstring_beg, :on_tstring_end, :on_tstring_content,
+        :on_embexpr_beg, :on_embexpr_end,
+        :on_lbracket, :on_rbracket,
+        :on_qwords_beg, :on_words_sep, :on_qwords_sep,
+        :on_lparen, :on_rparen,
+        :on_lbrace, :on_rbrace, :on_label,
+        :on_int, :on_float, :on_imaginary,
+        :on_comma, :on_sp, :on_ignored_nl,
+      ].freeze
+
+      DYNAMIC_TOKENS = [
+        :on_ident, :on_period,
+      ].freeze
+
+      STATIC_KEYWORDS = [
+        'true', 'false', 'nil',
+      ].freeze
+
+      STATIC_OPERATORS = [
+        '=>',
+      ].freeze
+
+      class << self
+        def available?
+          true
+        end
+
+        def static?(code)
+          return false if code.nil? || code.strip.empty? || syntax_error?(code)
+
+          Ripper.lex(code).each do |_, token, str|
+            case token
+            when *STATIC_TOKENS
+              # noop
+            when :on_kw
+              return false unless STATIC_KEYWORDS.include?(str)
+            when :on_op
+              return false unless STATIC_OPERATORS.include?(str)
+            when *DYNAMIC_TOKENS
+              return false
+            else
+              return false
+            end
+          end
+
+          !ShorthandSyntaxChecker.shorthand?(code)
+        end
+
+        def syntax_error?(code)
+          SyntaxChecker.new(code).parse
+          false
+        rescue SyntaxChecker::ParseError
+          true
+        end
+
+        class SyntaxChecker < Ripper
+          class ParseError < StandardError; end
+
+          private
+
+          def on_parse_error(*)
+            raise ParseError
+          end
+        end
+
+        class ShorthandSyntaxChecker < Ripper
+          class << self
+            def shorthand?(code)
+              instance = new(code)
+              instance.parse
+              instance.shorthand
+            end
+          end
+
+          attr_reader :shorthand
+
+          def initialize(*)
+            super
+            @shorthand = nil
+          end
+
+          private
+
+          def on_assoc_new(key, value)
+            @shorthand = true if value.nil?
+          end
+        end
+      end
+    else
+      class << self
+        def available?
+          false
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/3.2.0/gems/{temple-0.10.4 → temple-0.10.6}/lib/temple/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Temple
-  VERSION = '0.10.4'
+  VERSION = '0.10.6'
 end

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.8.0}/COPYING

@@ -1,5 +1,5 @@
 Copyright (c) 2010-2016 Ryan Tomayko <http://tomayko.com/about>
-Copyright (c) 2015-2023 Jeremy Evans
+Copyright (c) 2015-2026 Jeremy Evans and contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.8.0}/lib/tilt/asciidoc.rb

@@ -1,14 +1,21 @@
 # frozen_string_literal: true
-require_relative 'template'
-require 'asciidoctor'
-# AsciiDoc see: http://asciidoc.org/
 
-# Asciidoctor implementation for AsciiDoc see:
-# http://asciidoctor.github.com/
+# = AsciiDoc
+#
+# Asciidoctor implementation for AsciiDoc
 #
 # Asciidoctor is an open source, pure-Ruby processor for
 # converting AsciiDoc documents or strings into HTML 5,
 # DocBook 4.5 and other formats.
+#
+# === See also
+#
+# * http://asciidoc.org
+# * http://asciidoctor.github.com
+
+require_relative 'template'
+require 'asciidoctor'
+
 Tilt::AsciidoctorTemplate = Tilt::StaticTemplate.subclass do
   @options[:header_footer] = false if @options[:header_footer].nil?
   Asciidoctor.render(@data, @options)

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.8.0}/lib/tilt/babel.rb

@@ -1,4 +1,9 @@
 # frozen_string_literal: true
+
+# = Babel
+#
+#
+
 require_relative 'template'
 require 'babel/transpiler'
 

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.8.0}/lib/tilt/builder.rb

@@ -1,4 +1,8 @@
 # frozen_string_literal: true
+
+# = Builder
+#
+
 require_relative 'template'
 require 'builder'
 

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.8.0}/lib/tilt/coffee.rb

@@ -1,12 +1,22 @@
 # frozen_string_literal: true
+
+# CoffeeScript / Literate CoffeeScript template implementation.
+#
+# CoffeeScript templates do not support object scopes, locals, or yield.
+#
+# === See also
+#
+# * http://coffeescript.org
+#
+# === Related modules
+#
+# * Tilt::CoffeeScriptTemplate
+# * Tilt::CoffeeScriptLiterateTemplate
+
 require_relative 'template'
 require 'coffee_script'
 
 module Tilt
-  # CoffeeScript template implementation. See:
-  # http://coffeescript.org/
-  #
-  # CoffeeScript templates do not support object scopes, locals, or yield.
   class CoffeeScriptTemplate < StaticTemplate
     self.default_mime_type = 'application/javascript'
 

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.8.0}/lib/tilt/commonmarker.rb

@@ -1,4 +1,45 @@
 # frozen_string_literal: true
+#
+# = Markdown (<tt>markdown</tt>, <tt>md</tt>, <tt>mkd</tt>)
+#
+# Markdown is a lightweight markup language, created by John Gruber
+# and Aaron Swartz. For any markup that is not covered by Markdown’s syntax, HTML
+# is used.  Marking up plain text with Markdown markup is easy and Markdown
+# formatted texts are readable.
+#
+# === Example
+#
+#     Hello Markdown Templates
+#     ========================
+#
+#     Hello World. This is a paragraph.
+#
+# === Usage
+#
+# To wrap a Markdown formatted document with a layout:
+#
+#     layout = Tilt['erb'].new do
+#       "<!doctype html><title></title><%= yield %>"
+#     end
+#     data = Tilt['md'].new { "# hello tilt" }
+#     layout.render { data.render }
+#     # => "<!doctype html><title></title><h1>hello tilt</h1>\n"
+#
+# === Options
+#
+# ==== <tt>:smartypants => true|false</tt>
+#
+# Set <tt>true</tt> to enable [Smarty Pants][smartypants] style punctuation replacement.
+#
+# ==== <tt>:escape_html => true|false</tt>
+#
+# Set <tt>true</tt> disallow raw HTML in Markdown contents. HTML is converted to
+# literal text by escaping <tt><</tt> characters.
+#
+# === See also
+#
+# * {Markdown Syntax Documentation}[http://daringfireball.net/projects/markdown/syntax]
+
 require_relative 'template'
 require 'commonmarker'
 
@@ -9,14 +50,24 @@ if defined?(::Commonmarker)
   parse_opts = [
     :smart,
     :default_info_string,
+    :relaxed_tasklist_matching,
+    :relaxed_autolinks,
+    :leave_footnote_definitions,
+    :ignore_setext,
   ].freeze
   render_opts = [
     :hardbreaks,
     :github_pre_lang,
+    :full_info_string,
     :width,
     :unsafe,
     :escape,
     :sourcepos,
+    :escaped_char_spans,
+    :ignore_empty_links,
+    :gfm_quirks,
+    :prefer_fenced,
+    :tasklist_classes,
   ].freeze
   exts = [
     :strikethrough,
@@ -27,9 +78,23 @@ if defined?(::Commonmarker)
     :superscript,
     :header_ids,
     :footnotes,
+    :inline_footnotes,
     :description_lists,
     :front_matter_delimiter,
+    :multiline_block_quotes,
+    :math_dollars,
+    :math_code,
     :shortcodes,
+    :wikilinks_title_before_pipe,
+    :wikilinks_title_after_pipe,
+    :underline,
+    :spoiler,
+    :greentext,
+    :subscript,
+    :subtext,
+    :alerts,
+    :cjk_friendly_emphasis,
+    :highlight,
   ].freeze
 
   Tilt::CommonMarkerTemplate = Tilt::StaticTemplate.subclass do

data/bundle/ruby/3.2.0/gems/tilt-2.8.0/lib/tilt/csv.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# = CSV
+#
+# CSV Template implementation.
+#
+# === Example
+#
+#    # Example of csv template
+#    tpl = <<-EOS
+#      # header
+#      csv << ['NAME', 'ID']
+#
+#      # data rows
+#      @people.each do |person|
+#        csv << [person[:name], person[:id]]
+#      end
+#    EOS
+#
+#    @people = [
+#      {:name => "Joshua Peek", :id => 1},
+#      {:name => "Ryan Tomayko", :id => 2},
+#      {:name => "Simone Carletti", :id => 3}
+#    ]
+#
+#    template = Tilt::CSVTemplate.new { tpl }
+#    template.render(self)
+#
+# === See also
+#
+# * http://ruby-doc.org/stdlib/libdoc/csv/rdoc/CSV.html
+#
+# === Related module
+#
+# * Tilt::CSVTemplate
+
+require_relative 'template'
+require 'csv'
+
+module Tilt
+
+  class CSVTemplate < Template
+    self.default_mime_type = 'text/csv'
+
+    def prepare
+      @outvar = @options.delete(:outvar) || '_csvout'
+    end
+
+    def precompiled_template(locals)
+      <<-RUBY
+        #{@outvar} = CSV.generate(**#{@options}) do |csv|
+          #{@data}
+        end
+      RUBY
+    end
+
+    def precompiled(locals)
+      source, offset = super
+      [source, offset + 1]
+    end
+
+  end
+end