brakeman 5.2.2 → 7.1.1

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/erb/template.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Temple
+  # ERB example implementation
+  #
+  # Example usage:
+  #   Temple::ERB::Template.new { "<%= 'Hello, world!' %>" }.render
+  #
+  module ERB
+    # ERB Template class
+    Template = Temple::Templates::Tilt(Engine)
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/erb/trimming.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Temple
+  module ERB
+    # ERB trimming like in erubis
+    # Deletes spaces around '<% %>' and leave spaces around '<%= %>'.
+    # @api public
+    class Trimming < Filter
+      define_options trim: true
+
+      def on_multi(*exps)
+        exps = exps.each_with_index.map do |e,i|
+          if e.first == :static && i > 0 && exps[i-1].first == :code
+            [:static, e.last.lstrip]
+          elsif e.first == :static && i < exps.size-1 && exps[i+1].first == :code
+            [:static, e.last.rstrip]
+          else
+            e
+          end
+        end if options[:trim]
+        [:multi, *exps]
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/exceptions.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Temple
+  # Exception raised if invalid temple expression is found
+  #
+  # @api public
+  class InvalidExpression < RuntimeError
+  end
+
+  # Exception raised if something bad happens in a Temple filter
+  #
+  # @api public
+  class FilterError < RuntimeError
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Temple
+  # Temple base filter
+  # @api public
+  class Filter
+    include Utils
+    include Mixins::Dispatcher
+    include Mixins::Options
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/ambles.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    class Ambles < Filter
+      define_options :preamble, :postamble
+
+      def initialize(*)
+        super
+        @preamble = options[:preamble]
+        @postamble = options[:postamble]
+      end
+
+      def call(ast)
+        ret = [:multi]
+        ret << [:static, @preamble] if @preamble
+        ret << ast
+        ret << [:static, @postamble] if @postamble
+        ret
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/code_merger.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    # @api public
+    class CodeMerger < Filter
+      def on_multi(*exps)
+        result = [:multi]
+        code = nil
+
+        exps.each do |exp|
+          if exp.first == :code
+            if code
+              code << '; ' unless code =~ /\n\Z/
+              code << exp.last
+            else
+              code = exp.last.dup
+              result << [:code, code]
+            end
+          elsif code && exp.first == :newline
+            code << "\n"
+          else
+            result << compile(exp)
+            code = nil
+          end
+        end
+
+        result.size == 2 ? result[1] : result
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/control_flow.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    # Control flow filter which processes [:if, condition, yes-exp, no-exp]
+    # and [:block, code, content] expressions.
+    # This is useful for ruby code generation with lots of conditionals.
+    #
+    # @api public
+    class ControlFlow < Filter
+      def on_if(condition, yes, no = nil)
+        result = [:multi, [:code, "if #{condition}"], compile(yes)]
+        while no && no.first == :if
+          result << [:code, "elsif #{no[1]}"] << compile(no[2])
+          no = no[3]
+        end
+        result << [:code, 'else'] << compile(no) if no
+        result << [:code, 'end']
+        result
+      end
+
+      def on_case(arg, *cases)
+        result = [:multi, [:code, arg ? "case (#{arg})" : 'case']]
+        cases.map do |c|
+          condition, exp = c
+          result << [:code, condition == :else ? 'else' : "when #{condition}"] << compile(exp)
+        end
+        result << [:code, 'end']
+        result
+      end
+
+      def on_cond(*cases)
+        on_case(nil, *cases)
+      end
+
+      def on_block(code, exp)
+        [:multi,
+         [:code, code],
+         compile(exp),
+         [:code, 'end']]
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/dynamic_inliner.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    # Inlines several static/dynamic into a single dynamic.
+    #
+    # @api public
+    class DynamicInliner < Filter
+      def on_multi(*exps)
+        result = [:multi]
+        curr = nil
+        prev = []
+        state = :looking
+
+        exps.each do |exp|
+          type, arg = exp
+
+          case type
+          when :newline
+            if state == :looking
+              # We haven't found any static/dynamic, so let's just add it
+              result << exp
+            else
+              # We've found something, so let's make sure the generated
+              # dynamic contains a newline by escaping a newline and
+              # starting a new string:
+              #
+              # "Hello "\
+              # "#{@world}"
+              prev << exp
+              curr[1] << "\"\\\n\""
+            end
+          when :dynamic, :static
+            case state
+            when :looking
+              # Found a single static/dynamic. We don't want to turn this
+              # into a dynamic yet.  Instead we store it, and if we find
+              # another one, we add both then.
+              state = :single
+              prev = [exp]
+              curr = [:dynamic, '"'.dup]
+            when :single
+              # Yes! We found another one. Add the current dynamic to the result.
+              state = :several
+              result << curr
+            end
+            curr[1] << (type == :static ? arg.inspect[1..-2] : "\#{#{arg}}")
+          else
+            if state != :looking
+              # We need to add the closing quote.
+              curr[1] << '"'
+              # If we found a single exp last time, let's add it.
+              result.concat(prev) if state == :single
+            end
+            # Compile the current exp
+            result << compile(exp)
+            # Now we're looking for more!
+            state = :looking
+          end
+        end
+
+        if state != :looking
+          # We need to add the closing quote.
+          curr[1] << '"'
+          # If we found a single exp last time, let's add it.
+          result.concat(prev) if state == :single
+        end
+
+        result.size == 2 ? result[1] : result
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/dynamic_merger.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    # Compile [:multi, [:static, 'foo'], [:dynamic, 'bar']] to [:dynamic, '"foo#{bar}"']
+    class DynamicMerger < Filter
+      def on_multi(*exps)
+        exps = exps.dup
+        result = [:multi]
+        buffer = []
+
+        until exps.empty?
+          type, arg = exps.first
+          if type == :dynamic && arg.count("\n") == 0
+            buffer << exps.shift
+          elsif type == :static && exps.size > (count = arg.count("\n")) &&
+                exps[1, count].all? { |e| e == [:newline] }
+            (1 + count).times { buffer << exps.shift }
+          elsif type == :newline && exps.size > (count = count_newline(exps)) &&
+                exps[count].first == :static && count == exps[count].last.count("\n")
+            (count + 1).times { buffer << exps.shift }
+          else
+            result.concat(merge_dynamic(buffer))
+            buffer = []
+            result << compile(exps.shift)
+          end
+        end
+        result.concat(merge_dynamic(buffer))
+
+        result.size == 2 ? result[1] : result
+      end
+
+      private
+
+      def merge_dynamic(exps)
+        # Merge exps only when they have both :static and :dynamic
+        unless exps.any? { |type,| type == :static } && exps.any? { |type,| type == :dynamic }
+          return exps
+        end
+
+        strlit_body = String.new
+        exps.each do |type, arg|
+          case type
+          when :static
+            strlit_body << arg.dump.sub!(/\A"/, '').sub!(/"\z/, '').gsub('\n', "\n")
+          when :dynamic
+            strlit_body << "\#{#{arg}}"
+          when :newline
+            # newline is added by `gsub('\n', "\n")`
+          else
+            raise "unexpected type #{type.inspect} is given to #merge_dynamic"
+          end
+        end
+        [[:dynamic, "%Q\0#{strlit_body}\0"]]
+      end
+
+      def count_newline(exps)
+        count = 0
+        exps.each do |exp|
+          if exp == [:newline]
+            count += 1
+          else
+            return count
+          end
+        end
+        return count
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/encoding.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    # Try to encode input string
+    #
+    # @api public
+    class Encoding < Parser
+      define_options encoding: 'utf-8'
+
+      def call(s)
+        if options[:encoding] && s.respond_to?(:encoding)
+          old_enc = s.encoding
+          s = +s
+          s.force_encoding(options[:encoding])
+          # Fall back to old encoding if new encoding is invalid
+          unless s.valid_encoding?
+            s.force_encoding(old_enc)
+            s.force_encoding(::Encoding::BINARY) unless s.valid_encoding?
+          end
+        end
+        s
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/eraser.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    # Erase expressions with a certain type
+    #
+    # @api public
+    class Eraser < Filter
+      # [] is the empty type => keep all
+      define_options :erase, keep: [[]]
+
+      def compile(exp)
+        exp.first == :multi || (do?(:keep, exp) && !do?(:erase, exp)) ?
+          super(exp) : [:multi]
+      end
+
+      protected
+
+      def do?(list, exp)
+        options[list].to_a.map {|type| [*type] }.any? {|type| exp[0,type.size] == type }
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/escapable.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    # Escape dynamic or static expressions.
+    # This filter must be used after Temple::HTML::* and before the generators.
+    # It can be enclosed with Temple::Filters::DynamicInliner filters to
+    # reduce calls to Temple::Utils#escape_html.
+    #
+    # @api public
+    class Escapable < Filter
+      # Activate the usage of html_safe? if it is available (for Rails 3 for example)
+      define_options :escape_code,
+                     :disable_escape,
+                     use_html_safe: ''.respond_to?(:html_safe?)
+
+      def initialize(opts = {})
+        super
+        @escape_code = options[:escape_code] ||
+          "::Temple::Utils.escape_html#{options[:use_html_safe] ? '_safe' : ''}((%s))"
+        @escaper = eval("proc {|v| #{@escape_code % 'v'} }")
+        @escape = false
+      end
+
+      def on_escape(flag, exp)
+        old = @escape
+        @escape = flag && !options[:disable_escape]
+        compile(exp)
+      ensure
+        @escape = old
+      end
+
+      def on_static(value)
+        [:static, @escape ? @escaper[value] : value]
+      end
+
+      def on_dynamic(value)
+        [:dynamic, @escape ? @escape_code % value : value]
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/multi_flattener.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    # Flattens nested multi expressions
+    #
+    # @api public
+    class MultiFlattener < Filter
+      def on_multi(*exps)
+        # If the multi contains a single element, just return the element
+        return compile(exps.first) if exps.size == 1
+        result = [:multi]
+
+        exps.each do |exp|
+          exp = compile(exp)
+          if exp.first == :multi
+            result.concat(exp[1..-1])
+          else
+            result << exp
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/remove_bom.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    # Remove BOM from input string
+    #
+    # @api public
+    class RemoveBOM < Parser
+      def call(s)
+        return s if s.encoding.name !~ /^UTF-(8|16|32)(BE|LE)?/
+        s.gsub(Regexp.new("\\A\uFEFF".encode(s.encoding.name)), ''.freeze)
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/static_analyzer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    # Convert [:dynamic, code] to [:static, text] if code is static Ruby expression.
+    class StaticAnalyzer < Filter
+      def call(exp)
+        # Optimize only when Ripper is available.
+        if ::Temple::StaticAnalyzer.available?
+          super
+        else
+          exp
+        end
+      end
+
+      def on_dynamic(code)
+        if ::Temple::StaticAnalyzer.static?(code)
+          exp = [:static, eval(code).to_s]
+
+          newlines = code.count("\n")
+          if newlines == 0
+            exp
+          else
+            [:multi, exp, *newlines.times.map { [:newline] }]
+          end
+        else
+          [:dynamic, code]
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/static_merger.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    # Merges several statics into a single static.  Example:
+    #
+    #   [:multi,
+    #     [:static, "Hello "],
+    #     [:static, "World!"]]
+    #
+    # Compiles to:
+    #
+    #   [:static, "Hello World!"]
+    #
+    # @api public
+    class StaticMerger < Filter
+      def on_multi(*exps)
+        result = [:multi]
+        text = nil
+
+        exps.each do |exp|
+          if exp.first == :static
+            if text
+              text << exp.last
+            else
+              text = exp.last.dup
+              result << [:static, text]
+            end
+          else
+            result << compile(exp)
+            text = nil unless exp.first == :newline
+          end
+        end
+
+        result.size == 2 ? result[1] : result
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/string_splitter.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+begin
+  require 'ripper'
+rescue LoadError
+end
+
+module Temple
+  module Filters
+    # Compile [:dynamic, "foo#{bar}"] to [:multi, [:static, 'foo'], [:dynamic, 'bar']]
+    class StringSplitter < Filter
+      if defined?(Ripper) && Ripper.respond_to?(:lex)
+        class << self
+          # `code` param must be valid string literal
+          def compile(code)
+            [].tap do |exps|
+              tokens = Ripper.lex(code.strip)
+              tokens.pop while tokens.last && [:on_comment, :on_sp].include?(tokens.last[1])
+
+              if tokens.size < 2
+                raise(FilterError, "Expected token size >= 2 but got: #{tokens.size}")
+              end
+              compile_tokens!(exps, tokens)
+            end
+          end
+
+          private
+
+          def strip_quotes!(tokens)
+            _, type, beg_str = tokens.shift
+            if type != :on_tstring_beg
+              raise(FilterError, "Expected :on_tstring_beg but got: #{type}")
+            end
+
+            _, type, end_str = tokens.pop
+            if type != :on_tstring_end
+              raise(FilterError, "Expected :on_tstring_end but got: #{type}")
+            end
+
+            [beg_str, end_str]
+          end
+
+          def compile_tokens!(exps, tokens)
+            beg_str, end_str = strip_quotes!(tokens)
+
+            until tokens.empty?
+              _, type, str = tokens.shift
+
+              case type
+              when :on_tstring_content
+                beg_str, end_str = escape_quotes(beg_str, end_str)
+                exps << [:static, eval("#{beg_str}#{str}#{end_str}").to_s]
+              when :on_embexpr_beg
+                embedded = shift_balanced_embexpr(tokens)
+                exps << [:dynamic, embedded] unless embedded.empty?
+              end
+            end
+          end
+
+          # Some quotes are split-unsafe. Replace such quotes with null characters.
+          def escape_quotes(beg_str, end_str)
+            case [beg_str[-1], end_str]
+            when ['(', ')'], ['[', ']'], ['{', '}']
+              [beg_str.sub(/.\z/) { "\0" }, "\0"]
+            else
+              [beg_str, end_str]
+            end
+          end
+
+          def shift_balanced_embexpr(tokens)
+            String.new.tap do |embedded|
+              embexpr_open = 1
+
+              until tokens.empty?
+                _, type, str = tokens.shift
+                case type
+                when :on_embexpr_beg
+                  embexpr_open += 1
+                when :on_embexpr_end
+                  embexpr_open -= 1
+                  break if embexpr_open == 0
+                end
+
+                embedded << str
+              end
+            end
+          end
+        end
+
+        def on_dynamic(code)
+          return [:dynamic, code] unless string_literal?(code)
+          return [:dynamic, code] if code.include?("\n")
+
+          temple = [:multi]
+          StringSplitter.compile(code).each do |type, content|
+            case type
+            when :static
+              temple << [:static, content]
+            when :dynamic
+              temple << on_dynamic(content)
+            end
+          end
+          temple
+        end
+
+        private
+
+        def string_literal?(code)
+          return false if SyntaxChecker.syntax_error?(code)
+
+          type, instructions = Ripper.sexp(code)
+          return false if type != :program
+          return false if instructions.size > 1
+
+          type, _ = instructions.first
+          type == :string_literal
+        end
+
+        class SyntaxChecker < Ripper
+          class ParseError < StandardError; end
+
+          def self.syntax_error?(code)
+            self.new(code).parse
+            false
+          rescue ParseError
+            true
+          end
+
+          private
+
+          def on_parse_error(*)
+            raise ParseError
+          end
+        end
+      else
+        # Do nothing if ripper is unavailable
+        def call(ast)
+          ast
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/filters/validator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module Temple
+  module Filters
+    # Validates temple expression with given grammar
+    #
+    # @api public
+    class Validator < Filter
+      define_options grammar: Temple::Grammar
+
+      def compile(exp)
+        options[:grammar].validate!(exp)
+        exp
+      end
+    end
+  end
+end