brakeman 5.2.2 → 7.1.1

data/bundle/ruby/2.7.0/gems/slim-4.1.0/lib/slim/code_attributes.rb

@@ -1,67 +0,0 @@
-module Slim
-  # @api private
-  class CodeAttributes < Filter
-    define_options :merge_attrs
-
-    # Handle attributes expression `[:html, :attrs, *attrs]`
-    #
-    # @param [Array] attrs Array of temple expressions
-    # @return [Array] Compiled temple expression
-    def on_html_attrs(*attrs)
-      [:multi, *attrs.map {|a| compile(a) }]
-    end
-
-    # Handle attribute expression `[:html, :attr, name, value]`
-    #
-    # @param [String] name Attribute name
-    # @param [Array] value Value expression
-    # @return [Array] Compiled temple expression
-    def on_html_attr(name, value)
-      if value[0] == :slim && value[1] == :attrvalue && !options[:merge_attrs][name]
-        # We handle the attribute as a boolean attribute
-        escape, code = value[2], value[3]
-        case code
-        when 'true'
-          [:html, :attr, name, [:multi]]
-        when 'false', 'nil'
-          [:multi]
-        else
-          tmp = unique_name
-          [:multi,
-           [:code, "#{tmp} = #{code}"],
-           [:if, tmp,
-            [:if, "#{tmp} == true",
-             [:html, :attr, name, [:multi]],
-             [:html, :attr, name, [:escape, escape, [:dynamic, tmp]]]]]]
-        end
-      else
-        # Attribute with merging
-        @attr = name
-        super
-      end
-    end
-
-    # Handle attribute expression `[:slim, :attrvalue, escape, code]`
-    #
-    # @param [Boolean] escape Escape html
-    # @param [String] code Ruby code
-    # @return [Array] Compiled temple expression
-    def on_slim_attrvalue(escape, code)
-      # We perform attribute merging on Array values
-      if delimiter = options[:merge_attrs][@attr]
-        tmp = unique_name
-        [:multi,
-         [:code, "#{tmp} = #{code}"],
-         [:if, "Array === #{tmp}",
-          [:multi,
-           [:code, "#{tmp} = #{tmp}.flatten"],
-           [:code, "#{tmp}.map!(&:to_s)"],
-           [:code, "#{tmp}.reject!(&:empty?)"],
-           [:escape, escape, [:dynamic, "#{tmp}.join(#{delimiter.inspect})"]]],
-          [:escape, escape, [:dynamic, tmp]]]]
-      else
-        [:escape, escape, [:dynamic, code]]
-      end
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/slim-4.1.0/lib/slim/command.rb

@@ -1,128 +0,0 @@
-require 'slim'
-require 'optparse'
-
-module Slim
-  Engine.set_options pretty: false
-
-  # Slim commandline interface
-  # @api private
-  class Command
-    def initialize(args)
-      @args = args
-      @options = {}
-    end
-
-    # Run command
-    def run
-      @opts = OptionParser.new(&method(:set_opts))
-      @opts.parse!(@args)
-      process
-    end
-
-    private
-
-    # Configure OptionParser
-    def set_opts(opts)
-      opts.on('-s', '--stdin', 'Read input from standard input instead of an input file') do
-        @options[:input] = $stdin
-      end
-
-      opts.on('--trace', 'Show a full traceback on error') do
-        @options[:trace] = true
-      end
-
-      opts.on('-c', '--compile', 'Compile only but do not run') do
-        @options[:compile] = true
-      end
-
-      opts.on('-e', '--erb', 'Convert to ERB') do
-        @options[:erb] = true
-      end
-
-      opts.on('--rails', 'Generate rails compatible code (Implies --compile)') do
-        Engine.set_options disable_capture: true, generator: Temple::Generators::RailsOutputBuffer
-        @options[:compile] = true
-      end
-
-      opts.on('-r', '--require library', "Load library or plugin with -r slim/plugin") do |lib|
-        require lib.strip
-      end
-
-      opts.on('-p', '--pretty', 'Produce pretty html') do
-        Engine.set_options pretty: true
-      end
-
-      opts.on('-o', '--option name=code', String, 'Set slim option') do |str|
-        parts = str.split('=', 2)
-        Engine.options[parts.first.gsub(/\A:/, '').to_sym] = eval(parts.last)
-      end
-
-      opts.on('-l', '--locals Hash|YAML|JSON', String, 'Set local variables') do |locals|
-        @options[:locals] =
-          if locals =~ /\A\s*\{\s*\p{Word}+:/
-            eval(locals)
-          else
-            require 'yaml'
-            if RUBY_ENGINE == 'rbx'
-              begin
-                require 'psych'
-              rescue LoadError
-                $stderr.puts 'Please install psych gem as Rubunius ships with an old YAML engine.'
-              end
-            end
-            YAML.load(locals)
-          end
-      end
-
-      opts.on_tail('-h', '--help', 'Show this message') do
-        puts opts
-        exit
-      end
-
-      opts.on_tail('-v', '--version', 'Print version') do
-        puts "Slim #{VERSION}"
-        exit
-      end
-    end
-
-    # Process command
-    def process
-      args = @args.dup
-      unless @options[:input]
-        file = args.shift
-        if file
-          @options[:file] = file
-          @options[:input] = File.open(file, 'r')
-        else
-          @options[:file] = 'STDIN'
-          @options[:input] = $stdin
-        end
-      end
-
-      locals = @options.delete(:locals) || {}
-      result =
-        if @options[:erb]
-          require 'slim/erb_converter'
-          ERBConverter.new(file: @options[:file]).call(@options[:input].read)
-        elsif @options[:compile]
-          Engine.new(file: @options[:file]).call(@options[:input].read)
-        else
-          Template.new(@options[:file]) { @options[:input].read }.render(nil, locals)
-        end
-
-    rescue Exception => ex
-      raise ex if @options[:trace] || SystemExit === ex
-      $stderr.print "#{ex.class}: " if ex.class != RuntimeError
-      $stderr.puts ex.message
-      $stderr.puts '  Use --trace for backtrace.'
-      exit 1
-    else
-      unless @options[:output]
-        file = args.shift
-        @options[:output] = file ? File.open(file, 'w') : $stdout
-      end
-      @options[:output].puts(result)
-      exit 0
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/slim-4.1.0/lib/slim/controls.rb

@@ -1,60 +0,0 @@
-module Slim
-  # @api private
-  class Controls < Filter
-    define_options :disable_capture
-
-    IF_RE = /\A(if|unless)\b|\bdo\s*(\|[^\|]*\|)?\s*$/
-
-    # Handle control expression `[:slim, :control, code, content]`
-    #
-    # @param [String] code Ruby code
-    # @param [Array] content Temple expression
-    # @return [Array] Compiled temple expression
-    def on_slim_control(code, content)
-      [:multi,
-        [:code, code],
-        compile(content)]
-    end
-
-    # Handle output expression `[:slim, :output, escape, code, content]`
-    #
-    # @param [Boolean] escape Escape html
-    # @param [String] code Ruby code
-    # @param [Array] content Temple expression
-    # @return [Array] Compiled temple expression
-    def on_slim_output(escape, code, content)
-      if code =~ IF_RE
-        tmp = unique_name
-
-        [:multi,
-         # Capture the result of the code in a variable. We can't do
-         # `[:dynamic, code]` because it's probably not a complete
-         # expression (which is a requirement for Temple).
-         [:block, "#{tmp} = #{code}",
-
-          # Capture the content of a block in a separate buffer. This means
-          # that `yield` will not output the content to the current buffer,
-          # but rather return the output.
-          #
-          # The capturing can be disabled with the option :disable_capture.
-          # Output code in the block writes directly to the output buffer then.
-          # Rails handles this by replacing the output buffer for helpers.
-          options[:disable_capture] ? compile(content) : [:capture, unique_name, compile(content)]],
-
-         # Output the content.
-         [:escape, escape, [:dynamic, tmp]]]
-      else
-        [:multi, [:escape, escape, [:dynamic, code]], content]
-      end
-    end
-
-    # Handle text expression `[:slim, :text, type, content]`
-    #
-    # @param [Symbol] type Text type
-    # @param [Array] content Temple expression
-    # @return [Array] Compiled temple expression
-    def on_slim_text(type, content)
-      compile(content)
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/slim-4.1.0/lib/slim/do_inserter.rb

@@ -1,33 +0,0 @@
-module Slim
-  # In Slim you don't need the do keyword sometimes. This
-  # filter adds the missing keyword.
-  #
-  #   - 10.times
-  #     | Hello
-  #
-  # @api private
-  class DoInserter < Filter
-    BLOCK_REGEX = /(\A(if|unless|else|elsif|when|begin|rescue|ensure|case)\b)|\bdo\s*(\|[^\|]*\|\s*)?\Z/
-
-    # Handle control expression `[:slim, :control, code, content]`
-    #
-    # @param [String] code Ruby code
-    # @param [Array] content Temple expression
-    # @return [Array] Compiled temple expression
-    def on_slim_control(code, content)
-      code = code + ' do' unless code =~ BLOCK_REGEX || empty_exp?(content)
-      [:slim, :control, code, compile(content)]
-    end
-
-    # Handle output expression `[:slim, :output, escape, code, content]`
-    #
-    # @param [Boolean] escape Escape html
-    # @param [String] code Ruby code
-    # @param [Array] content Temple expression
-    # @return [Array] Compiled temple expression
-    def on_slim_output(escape, code, content)
-      code = code + ' do' unless code =~ BLOCK_REGEX || empty_exp?(content)
-      [:slim, :output, escape, code, compile(content)]
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/slim-4.1.0/lib/slim/embedded.rb

@@ -1,248 +0,0 @@
-module Slim
-  # @api private
-  class TextCollector < Filter
-    def call(exp)
-      @collected = ''
-      super(exp)
-      @collected
-    end
-
-    def on_slim_interpolate(text)
-      @collected << text
-      nil
-    end
-  end
-
-  # @api private
-  class NewlineCollector < Filter
-    def call(exp)
-      @collected = [:multi]
-      super(exp)
-      @collected
-    end
-
-    def on_newline
-      @collected << [:newline]
-      nil
-    end
-  end
-
-  # @api private
-  class OutputProtector < Filter
-    def call(exp)
-      @protect, @collected, @tag = [], '', "%#{object_id.abs.to_s(36)}%"
-      super(exp)
-      @collected
-    end
-
-    def on_static(text)
-      @collected << text
-      nil
-    end
-
-    def on_slim_output(escape, text, content)
-      @collected << @tag
-      @protect << [:slim, :output, escape, text, content]
-      nil
-    end
-
-    def unprotect(text)
-      block = [:multi]
-      while text =~ /#{@tag}/
-        block << [:static, $`]
-        block << @protect.shift
-        text = $'
-      end
-      block << [:static, text]
-    end
-  end
-
-  # Temple filter which processes embedded engines
-  # @api private
-  class Embedded < Filter
-    @engines = {}
-
-    class << self
-      attr_reader :engines
-
-      # Register embedded engine
-      #
-      # @param [String] name Name of the engine
-      # @param [Class]  klass Engine class
-      # @param option_filter List of options to pass to engine.
-      #                      Last argument can be default option hash.
-      def register(name, klass, *option_filter)
-        name = name.to_sym
-        local_options = option_filter.last.respond_to?(:to_hash) ? option_filter.pop.to_hash : {}
-        define_options(name, *option_filter)
-        klass.define_options(name)
-        engines[name.to_sym] = proc do |options|
-          klass.new({}.update(options).delete_if {|k,v| !option_filter.include?(k) && k != name }.update(local_options))
-        end
-      end
-
-      def create(name, options)
-        constructor = engines[name] || raise(Temple::FilterError, "Embedded engine #{name} not found")
-        constructor.call(options)
-      end
-    end
-
-    define_options :enable_engines, :disable_engines
-
-    def initialize(opts = {})
-      super
-      @engines = {}
-      @enabled = normalize_engine_list(options[:enable_engines])
-      @disabled = normalize_engine_list(options[:disable_engines])
-    end
-
-    def on_slim_embedded(name, body, attrs)
-      name = name.to_sym
-      raise(Temple::FilterError, "Embedded engine #{name} is disabled") unless enabled?(name)
-      @engines[name] ||= self.class.create(name, options)
-      @engines[name].on_slim_embedded(name, body, attrs)
-    end
-
-    def enabled?(name)
-      (!@enabled || @enabled.include?(name)) &&
-        (!@disabled || !@disabled.include?(name))
-    end
-
-    protected
-
-    def normalize_engine_list(list)
-      raise(ArgumentError, "Option :enable_engines/:disable_engines must be String or Symbol list") unless !list || Array === list
-      list && list.map(&:to_sym)
-    end
-
-    class Engine < Filter
-      protected
-
-      def collect_text(body)
-        @text_collector ||= TextCollector.new
-        @text_collector.call(body)
-      end
-
-      def collect_newlines(body)
-        @newline_collector ||= NewlineCollector.new
-        @newline_collector.call(body)
-      end
-    end
-
-    # Basic tilt engine
-    class TiltEngine < Engine
-      def on_slim_embedded(engine, body, attrs)
-        tilt_engine = Tilt[engine] || raise(Temple::FilterError, "Tilt engine #{engine} is not available.")
-        tilt_options = options[engine.to_sym] || {}
-        tilt_options[:default_encoding] ||= 'utf-8'
-        [:multi, tilt_render(tilt_engine, tilt_options, collect_text(body)), collect_newlines(body)]
-      end
-
-      protected
-
-      def tilt_render(tilt_engine, tilt_options, text)
-        [:static, tilt_engine.new(tilt_options) { text }.render]
-      end
-    end
-
-    # Sass engine which supports :pretty option
-    class SassEngine < TiltEngine
-      define_options :pretty
-
-      protected
-
-      def tilt_render(tilt_engine, tilt_options, text)
-        text = tilt_engine.new(tilt_options.merge(
-          style: options[:pretty] ? :expanded : :compressed,
-          cache: false)) { text }.render
-        text.chomp!
-        [:static, text]
-      end
-    end
-
-    # Static template with interpolated ruby code
-    class InterpolateTiltEngine < TiltEngine
-      def collect_text(body)
-        output_protector.call(interpolation.call(body))
-      end
-
-      def tilt_render(tilt_engine, tilt_options, text)
-        output_protector.unprotect(tilt_engine.new(tilt_options) { text }.render)
-      end
-
-      private
-
-      def interpolation
-        @interpolation ||= Interpolation.new
-      end
-
-      def output_protector
-        @output_protector ||= OutputProtector.new
-      end
-    end
-
-    # Tag wrapper engine
-    # Generates a html tag and wraps another engine (specified via :engine option)
-    class TagEngine < Engine
-      disable_option_validator!
-
-      def on_slim_embedded(engine, body, attrs)
-
-        unless options[:attributes].empty?
-          options[:attributes].map do|k, v|
-            attrs << [:html, :attr, k, [:static, v]]
-          end
-        end
-
-        if options[:engine]
-          opts = {}.update(options)
-          opts.delete(:engine)
-          opts.delete(:tag)
-          opts.delete(:attributes)
-          @engine ||= options[:engine].new(opts)
-          body = @engine.on_slim_embedded(engine, body, attrs)
-        end
-
-        [:html, :tag, options[:tag], attrs, body]
-      end
-
-    end
-
-    # Javascript wrapper engine.
-    # Like TagEngine, but can wrap content in html comment or cdata.
-    class JavaScriptEngine < TagEngine
-      disable_option_validator!
-
-      set_options tag: :script, attributes: {}
-
-      def on_slim_embedded(engine, body, attrs)
-        super(engine, [:html, :js, body], attrs)
-      end
-    end
-
-    # Embeds ruby code
-    class RubyEngine < Engine
-      def on_slim_embedded(engine, body, attrs)
-        [:multi, [:newline], [:code, "#{collect_text(body)}\n"]]
-      end
-    end
-
-    # These engines are executed at compile time, embedded ruby is interpolated
-    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,  attributes: { type: 'text/css' },         engine: TiltEngine
-    register :sass,       TagEngine, :pretty, tag: :style, attributes: { type: 'text/css' }, engine: SassEngine
-    register :scss,       TagEngine, :pretty, tag: :style, attributes: { type: 'text/css' }, engine: SassEngine
-
-    # Embedded javascript/css
-    register :javascript, JavaScriptEngine
-    register :css,        TagEngine, tag: :style,  attributes: { type: 'text/css' }
-
-    # Embedded ruby code
-    register :ruby,       RubyEngine
-  end
-end

data/bundle/ruby/2.7.0/gems/slim-4.1.0/lib/slim/end_inserter.rb

@@ -1,62 +0,0 @@
-module Slim
-  # In Slim you don't need to close any blocks:
-  #
-  #   - if Slim.awesome?
-  #     | But of course it is!
-  #
-  # However, the parser is not smart enough (and that's a good thing) to
-  # automatically insert end's where they are needed. Luckily, this filter
-  # does *exactly* that (and it does it well!)
-  #
-  # @api private
-  class EndInserter < Filter
-    IF_RE = /\A(if|begin|unless|else|elsif|when|rescue|ensure)\b|\bdo\s*(\|[^\|]*\|)?\s*$/
-    ELSE_RE = /\A(else|elsif|when|rescue|ensure)\b/
-    END_RE = /\Aend\b/
-
-    # Handle multi expression `[:multi, *exps]`
-    #
-    # @return [Array] Corrected Temple expression with ends inserted
-    def on_multi(*exps)
-      result = [:multi]
-      # This variable is true if the previous line was
-      # (1) a control code and (2) contained indented content.
-      prev_indent = false
-
-      exps.each do |exp|
-        if control?(exp)
-          raise(Temple::FilterError, 'Explicit end statements are forbidden') if exp[2] =~ END_RE
-
-          # Two control code in a row. If this one is *not*
-          # an else block, we should close the previous one.
-          append_end(result) if prev_indent && exp[2] !~ ELSE_RE
-
-          # Indent if the control code starts a block.
-          prev_indent = exp[2] =~ IF_RE
-        elsif exp[0] != :newline && prev_indent
-          # This is *not* a control code, so we should close the previous one.
-          # Ignores newlines because they will be inserted after each line.
-          append_end(result)
-          prev_indent = false
-        end
-
-        result << compile(exp)
-      end
-
-      # The last line can be a control code too.
-      prev_indent ? append_end(result) : result
-    end
-
-    private
-
-    # Appends an end
-    def append_end(result)
-      result << [:code, 'end']
-    end
-
-    # Checks if an expression is a Slim control code
-    def control?(exp)
-      exp[0] == :slim && exp[1] == :control
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/slim-4.1.0/lib/slim/engine.rb

@@ -1,39 +0,0 @@
-# The Slim module contains all Slim related classes (e.g. Engine, Parser).
-# Plugins might also reside within the Slim module (e.g. Include, Smart).
-# @api public
-module Slim
-  # Slim engine which transforms slim code to executable ruby code
-  # @api public
-  class Engine < Temple::Engine
-    # This overwrites some Temple default options or sets default options for Slim specific filters.
-    # It is recommended to set the default settings only once in the code and avoid duplication. Only use
-    # `define_options` when you have to override some default settings.
-    define_options pretty: false,
-                   sort_attrs: true,
-                   format: :xhtml,
-                   attr_quote: '"',
-                   merge_attrs: {'class' => ' '},
-                   generator: Temple::Generators::StringBuffer,
-                   default_tag: 'div'
-
-    filter :Encoding
-    filter :RemoveBOM
-    use Slim::Parser
-    use Slim::Embedded
-    use Slim::Interpolation
-    use Slim::Splat::Filter
-    use Slim::DoInserter
-    use Slim::EndInserter
-    use Slim::Controls
-    html :AttributeSorter
-    html :AttributeMerger
-    use Slim::CodeAttributes
-    use(:AttributeRemover) { Temple::HTML::AttributeRemover.new(remove_empty_attrs: options[:merge_attrs].keys) }
-    html :Pretty
-    filter :Escapable
-    filter :ControlFlow
-    filter :MultiFlattener
-    filter :StaticMerger
-    use(:Generator) { options[:generator] }
-  end
-end

data/bundle/ruby/2.7.0/gems/slim-4.1.0/lib/slim/erb_converter.rb

@@ -1,14 +0,0 @@
-require 'slim'
-
-module Slim
-  # Slim to ERB converter
-  #
-  # @example Conversion
-  #   Slim::ERBConverter.new(options).call(slim_code) # outputs erb_code
-  #
-  # @api public
-  class ERBConverter < Engine
-    replace :StaticMerger, Temple::Filters::CodeMerger
-    replace :Generator, Temple::Generators::ERB
-  end
-end

data/bundle/ruby/2.7.0/gems/slim-4.1.0/lib/slim/filter.rb

@@ -1,30 +0,0 @@
-module Slim
-  # Base class for Temple filters used in Slim
-  #
-  # This base filter passes everything through and allows
-  # to override only some methods without affecting the rest
-  # of the expression.
-  #
-  # @api private
-  class Filter < Temple::HTML::Filter
-    # Pass-through handler
-    def on_slim_text(type, content)
-      [:slim, :text, type, compile(content)]
-    end
-
-    # Pass-through handler
-    def on_slim_embedded(type, content, attrs)
-      [:slim, :embedded, type, compile(content), attrs]
-    end
-
-    # Pass-through handler
-    def on_slim_control(code, content)
-      [:slim, :control, code, compile(content)]
-    end
-
-    # Pass-through handler
-    def on_slim_output(escape, code, content)
-      [:slim, :output, escape, code, compile(content)]
-    end
-  end
-end