brakeman 6.2.2 → 8.0.6

data/bundle/ruby/{3.1.0/gems/slim-5.2.1 → 3.2.0/gems/slim-5.2.2}/README.md

@@ -41,7 +41,7 @@ A short list of the features...
 ### What is Slim?
 
 Slim is a fast, lightweight templating engine with support for __Rails 5 and later__. It has been heavily tested on all major ruby implementations. We use
-continuous integration (github actions).
+continuous integration (GitHub actions).
 
 Slim's core syntax is guided by one thought: "What's the minimum required to make this work".
 
@@ -502,7 +502,7 @@ You can also break ruby attributes with backslash `\` or trailing `,` as describ
 #### Boolean attributes
 
 The attribute values `true`, `false` and `nil` are interpreted
-as booleans. If you use the attribute wrapper you can omit the attribute assigment.
+as booleans. If you use the attribute wrapper you can omit the attribute assignment.
 
 ~~~ slim
 input type="text" disabled="disabled"
@@ -578,7 +578,7 @@ with the :tag key.
 
 ~~~ slim
 ruby:
-  def a_unless_current
+  def self.a_unless_current
     @page_current ? {tag: 'span'} : {tag: 'a', href: 'https://slim-template.github.io/'}
   end
 - @page_current = true
@@ -696,7 +696,7 @@ which renders to
 ~~~ html
 <script data-binding="products" type="text/javascript">
 [{"name": "product1", "price": "$100"},
- {"name": "prodcut2", "price": "$200"}]
+ {"name": "product2", "price": "$200"}]
 </script>
 ~~~
 
@@ -902,8 +902,8 @@ Supported engines:
 | css: | none | Shortcut | Shortcut to embed css code and wrap in style tag |
 | sass: | sass-embedded or sassc or sass | Compile time | Embed sass code and wrap in style tag |
 | scss: | sass-embedded or sassc or sass | Compile time | Embed scss code and wrap in style tag |
-| less: | less | Compile time | Embed less css code and wrap in style tag |
 | coffee: | coffee-script | Compile time | Compile coffee script code and wrap in script tag |
+| asciidoc: | asciidoctor | Compile time + Interpolation | Compile AsciiDoc code and interpolate #\{variables} in text |
 | markdown: | redcarpet/rdiscount/kramdown | Compile time + Interpolation | Compile markdown code and interpolate #\{variables} in text |
 | textile: | redcloth | Compile time + Interpolation | Compile textile code and interpolate #\{variables} in text |
 | rdoc: | rdoc | Compile time + Interpolation | Compile rdoc code and interpolate #\{variables} in text |
@@ -918,7 +918,6 @@ You can also specify HTML attributes for the following embedded engines:
 * Javascript
 * CSS
 * CoffeeScript
-* LESS
 * SASS
 * SCSS
 
@@ -1114,11 +1113,11 @@ There are two ways to resolve it:
 * Set `splat_prefix` to any custom value, double asterisk, for example: `splat_prefix: '**'`. Now structural directives should work as expected. Remember that now splat attributes should be written with new custom prefix before them.
 * Use alternative directive syntax without asterisk.
 
-#### Attribute delimeters
+#### Attribute delimiters
 
 Angular and slim both uses brackets in their syntax. So there are also two ways:
 * Use alternative syntax for binding (`bind-...` and so on)
-* Limit attribute delimeters to curly braces only:
+* Limit attribute delimiters to curly braces only:
 ```
 code_attr_delims: {
  '{' => '}',
@@ -1196,12 +1195,11 @@ There are plugins for various text editors (including the most important ones -
 * [Textmate / Sublime Text](https://github.com/slim-template/ruby-slim.tmbundle)
 * [Espresso text editor](https://github.com/slim-template/Slim-Sugar)
 * [Coda](https://github.com/slim-template/Coda-2-Slim.mode)
-* [Atom](https://github.com/slim-template/language-slim)
 * VS Code ([Official marketplace](https://marketplace.visualstudio.com/items?itemName=sianglim.slim), [Open VSX registry](https://open-vsx.org/extension/sianglim/slim))
 
 ### Template Converters (HAML, ERB, ...)
 
-* Slim can be converted to ERB using `slimrb` or `Slim::ERBConverter' which are both included in the Slim gem
+* Slim can be converted to ERB using `slimrb` or `Slim::ERBConverter` which are both included in the Slim gem
 * [Haml2Slim converter](https://github.com/slim-template/haml2slim)
 * [ERB2Slim, HTML2Slim converter](https://github.com/slim-template/html2slim)
 
@@ -1214,12 +1212,7 @@ There are plugins for various text editors (including the most important ones -
    But we would be happy if you chose Slim also for any other reason, we assure
    you performance will not be an obstacle.*
 
-Run the benchmarks with `rake bench`. You can add the option `slow` to
-run the slow parsing benchmark which needs more time. You can also increase the number of iterations.
-
-~~~
-$ rake bench slow=1 iterations=1000
-~~~
+For up-to-date benchmarks, please refer to our dedicated [Template engine benchmarks](https://github.com/slim-template/benchmarks) repository.
 
 ### Test suite and continuous integration
 
@@ -1259,7 +1252,8 @@ Slim is released under the [MIT license](http://www.opensource.org/licenses/MIT)
 
 ## Donations and sponsoring
 
-If you want to support this project please visit the GitHub sponsors page.
+This project relies on sponsoring for its continued maintenance. If you want to
+support the project, please visit the GitHub sponsors page.
 
 [![GitHub Sponsors](https://img.shields.io/github/sponsors/slim-template)](https://github.com/sponsors/slim-template)
 
@@ -1281,7 +1275,6 @@ Syntax highlighting:
 * [Textmate / Sublime Text](https://github.com/slim-template/ruby-slim.tmbundle)
 * [Espresso text editor](https://github.com/slim-template/Slim-Sugar)
 * [Coda](https://github.com/slim-template/Coda-2-Slim.mode)
-* [Atom](https://github.com/slim-template/language-slim)
 
 Static code analysis:
 
@@ -1297,17 +1290,19 @@ Template Converters (HAML, ERB, ...):
 Language ports/Similar languages:
 
 * [Sliq (Slim/Liquid integration)](https://github.com/slim-template/sliq)
-* [Slm (Slim port to Javascript)](https://github.com/slm-lang/slm)
-* [Coffee script plugin for Slim](https://github.com/yury/coffee-views)
-* [Clojure port of Slim](https://github.com/chaslemley/slim.clj)
 * [Hamlet.rb (Similar template language)](https://github.com/gregwebs/hamlet.rb)
-* [Plim (Python port of Slim)](https://github.com/2nd/plim)
+* [Slm (Slim port to Javascript)](https://github.com/slm-lang/slm)
 * [Skim (Slim for Javascript)](https://github.com/jfirebaugh/skim)
 * [Emblem.js (Javascript, similar to Slim)](https://github.com/machty/emblem.js)
-* [Hamlit (High performance Haml implementation, based on Temple like Slim)](https://github.com/k0kubun/hamlit)
-* [Faml (Faster Haml implementation, also using Temple like Slim)](https://github.com/eagletmt/faml)
-* [Haml (Older engine which inspired Slim)](https://github.com/haml/haml)
-* [Pug (Similar engine for javascript)](https://github.com/pugjs/pug)
+* [Jade (Similar engine for javascript)](https://github.com/visionmedia/jade)
+* [Pug (Successor of Jade, Similar engine for javascript)](https://github.com/pugjs/pug)
+* [Coffee script plugin for Slim](https://github.com/yury/coffee-views)
+* [Plim (Python port of Slim)](https://github.com/2nd/plim)
+* [Trim-Template (Python template engine inspired by Slim)](https://github.com/opensourceame/trim-template)
+* [Clojure port of Slim](https://github.com/chaslemley/slim.clj)
+* [Hamlit (Haml implementation, using Temple like Slim)](https://github.com/k0kubun/hamlit)
+* [Faml (Haml implementation, using Temple like Slim)](https://github.com/eagletmt/faml)
+* [Haml (Older template engine which inspired Slim)](https://github.com/haml/haml)
 * [Sweet (Similar engine which also allows to write classes and functions)](https://github.com/joaomdmoura/sweet)
 * [Amber (Similar engine for Go)](https://github.com/eknkc/amber)
 * [Slang (Slim-inspired templating language for Crystal)](https://github.com/jeromegn/slang)

data/bundle/ruby/{3.1.0/gems/slim-5.2.1 → 3.2.0/gems/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.1.0/gems/slim-5.2.1 → 3.2.0/gems/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.1.0/gems/slim-5.2.1 → 3.2.0/gems/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.1.0/gems/slim-5.2.1 → 3.2.0/gems/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.1.0/gems/temple-0.10.3 → 3.2.0/gems/temple-0.10.6}/CHANGES

@@ -1,3 +1,15 @@
+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)
+
 0.10.3
 
   * Remove test files from the gem package (#146)

data/bundle/ruby/{3.1.0/gems/temple-0.10.3 → 3.2.0/gems/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.1.0/gems/temple-0.10.3 → 3.2.0/gems/temple-0.10.6}/lib/temple/filters/encoding.rb

@@ -10,7 +10,7 @@ module Temple
       def call(s)
         if options[:encoding] && s.respond_to?(:encoding)
           old_enc = s.encoding
-          s = s.dup if s.frozen?
+          s = +s
           s.force_encoding(options[:encoding])
           # Fall back to old encoding if new encoding is invalid
           unless s.valid_encoding?

data/bundle/ruby/{3.1.0/gems/temple-0.10.3 → 3.2.0/gems/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.1.0/gems/temple-0.10.3 → 3.2.0/gems/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.1.0/gems/temple-0.10.3 → 3.2.0/gems/temple-0.10.6}/lib/temple/version.rb

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