brakeman 5.2.2 → 7.1.1

data/bundle/ruby/2.7.0/gems/tilt-2.0.10/lib/tilt/redcarpet.rb

@@ -1,83 +0,0 @@
-require 'tilt/template'
-require 'redcarpet'
-
-module Tilt
-  # Compatibility mode for Redcarpet 1.x
-  class Redcarpet1Template < Template
-    self.default_mime_type = 'text/html'
-
-    ALIAS = {
-      :escape_html => :filter_html,
-      :smartypants => :smart
-    }
-
-    FLAGS = [:smart, :filter_html, :smartypants, :escape_html]
-
-    def flags
-      FLAGS.select { |flag| options[flag] }.map { |flag| ALIAS[flag] || flag }
-    end
-
-    def prepare
-      @engine = RedcarpetCompat.new(data, *flags)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
-  end
-
-  # Future proof mode for Redcarpet 2.x (not yet released)
-  class Redcarpet2Template < Template
-    self.default_mime_type = 'text/html'
-
-    def generate_renderer
-      renderer = options.delete(:renderer) || ::Redcarpet::Render::HTML.new(options)
-      return renderer unless options.delete(:smartypants)
-      return renderer if renderer.is_a?(Class) && renderer <= ::Redcarpet::Render::SmartyPants
-
-      if renderer == ::Redcarpet::Render::XHTML
-        ::Redcarpet::Render::SmartyHTML.new(:xhtml => true)
-      elsif renderer == ::Redcarpet::Render::HTML
-        ::Redcarpet::Render::SmartyHTML
-      elsif renderer.is_a? Class
-        Class.new(renderer) { include ::Redcarpet::Render::SmartyPants }
-      else
-        renderer.extend ::Redcarpet::Render::SmartyPants
-      end
-    end
-
-    def prepare
-      # try to support the same aliases
-      Redcarpet1Template::ALIAS.each do |opt, aka|
-        next if options.key? opt or not options.key? aka
-        options[opt] = options.delete(aka)
-      end
-
-      # only raise an exception if someone is trying to enable :escape_html
-      options.delete(:escape_html) unless options[:escape_html]
-
-      @engine = ::Redcarpet::Markdown.new(generate_renderer, options)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.render(data)
-    end
-
-    def allows_script?
-      false
-    end
-  end
-
-  if defined? ::Redcarpet::Render and defined? ::Redcarpet::Markdown
-    RedcarpetTemplate = Redcarpet2Template
-  else
-    RedcarpetTemplate = Redcarpet1Template
-  end
-end
-

data/bundle/ruby/2.7.0/gems/tilt-2.0.10/lib/tilt/redcloth.rb

@@ -1,23 +0,0 @@
-require 'tilt/template'
-require 'redcloth'
-
-module Tilt
-  # RedCloth implementation. See:
-  # http://redcloth.org/
-  class RedClothTemplate < Template
-    def prepare
-      @engine = RedCloth.new(data)
-      options.each {|k, v| @engine.send("#{k}=", v) if @engine.respond_to? "#{k}="}
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end
-

data/bundle/ruby/2.7.0/gems/tilt-2.0.10/lib/tilt/rst-pandoc.rb

@@ -1,18 +0,0 @@
-require 'tilt/template'
-require 'tilt/pandoc'
-
-module Tilt
-  # Pandoc reStructuredText implementation. See:
-  # http://pandoc.org/
-  # Use PandocTemplate and specify input format
-  class RstPandocTemplate < PandocTemplate
-    def tilt_to_pandoc_mapping
-      { :smartypants => :smart }
-    end
-
-    def pandoc_options
-      options.merge!(f: 'rst')
-      super
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/tilt-2.0.10/lib/tilt/sass.rb

@@ -1,52 +0,0 @@
-require 'tilt/template'
-
-module Tilt
-  # Sass template implementation. See:
-  # http://haml.hamptoncatlin.com/
-  #
-  # Sass templates do not support object scopes, locals, or yield.
-  class SassTemplate < Template
-    self.default_mime_type = 'text/css'
-
-    begin
-      require 'sassc'
-      Sass = ::SassC
-    rescue LoadError => err
-      begin
-        require 'sass'
-        Sass = ::Sass
-      rescue LoadError
-        raise err
-      end
-    end
-
-    def prepare
-      @engine = Sass::Engine.new(data, sass_options)
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.render
-    end
-
-    def allows_script?
-      false
-    end
-
-  private
-    def sass_options
-      options.merge(:filename => eval_file, :line => line, :syntax => :sass)
-    end
-  end
-
-  # Sass's new .scss type template implementation.
-  class ScssTemplate < SassTemplate
-    self.default_mime_type = 'text/css'
-
-  private
-    def sass_options
-      options.merge(:filename => eval_file, :line => line, :syntax => :scss)
-    end
-  end
-
-end
-

data/bundle/ruby/2.7.0/gems/tilt-2.0.10/lib/tilt/sigil.rb

@@ -1,34 +0,0 @@
-require 'open3'
-require 'shellwords'
-
-module Tilt
-  # Standalone string interpolator and template processor implementation in Go.
-  # see: https://github.com/gliderlabs/sigil
-  class SigilTemplate < Template
-    def prepare
-    end
-
-    def evaluate(scope, locals, &block)
-      variables = locals.map {|k, v| "#{k}=#{v}" }
-
-      cmd = ['sigil']
-
-      unless variables.empty?
-        cmd << '-p'
-        cmd.concat(variables)
-      end
-
-      out, err, status = Open3.capture3(*cmd, :stdin_data => data)
-
-      if status.success?
-        out.chomp
-      else
-        raise err.chomp.gsub('<stdin>', file)
-      end
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/tilt-2.0.10/lib/tilt/string.rb

@@ -1,21 +0,0 @@
-require 'tilt/template'
-
-module Tilt
-  # The template source is evaluated as a Ruby string. The #{} interpolation
-  # syntax can be used to generated dynamic output.
-  class StringTemplate < Template
-    def prepare
-      hash = "TILT#{data.hash.abs}"
-      @code = String.new("<<#{hash}.chomp\n#{data}\n#{hash}")
-    end
-
-    def precompiled_template(locals)
-      @code
-    end
-
-    def precompiled(locals)
-      source, offset = super
-      [source, offset + 1]
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/tilt-2.0.10/lib/tilt/template.rb

@@ -1,297 +0,0 @@
-require 'thread'
-
-module Tilt
-  # @private
-  TOPOBJECT = if RUBY_VERSION >= '2.0'
-    # @private
-    module CompiledTemplates
-      self
-    end
-  elsif RUBY_VERSION >= '1.9'
-    BasicObject
-  else
-    Object
-  end
-  # @private
-  LOCK = Mutex.new
-
-  # Base class for template implementations. Subclasses must implement
-  # the #prepare method and one of the #evaluate or #precompiled_template
-  # methods.
-  class Template
-    # Template source; loaded from a file or given directly.
-    attr_reader :data
-
-    # The name of the file where the template data was loaded from.
-    attr_reader :file
-
-    # The line number in #file where template data was loaded from.
-    attr_reader :line
-
-    # A Hash of template engine specific options. This is passed directly
-    # to the underlying engine and is not used by the generic template
-    # interface.
-    attr_reader :options
-
-    class << self
-      # An empty Hash that the template engine can populate with various
-      # metadata.
-      def metadata
-        @metadata ||= {}
-      end
-
-      # @deprecated Use `.metadata[:mime_type]` instead.
-      def default_mime_type
-        metadata[:mime_type]
-      end
-
-      # @deprecated Use `.metadata[:mime_type] = val` instead.
-      def default_mime_type=(value)
-        metadata[:mime_type] = value
-      end
-    end
-
-    # Create a new template with the file, line, and options specified. By
-    # default, template data is read from the file. When a block is given,
-    # it should read template data and return as a String. When file is nil,
-    # a block is required.
-    #
-    # All arguments are optional.
-    def initialize(file=nil, line=1, options={}, &block)
-      @file, @line, @options = nil, 1, {}
-
-      [options, line, file].compact.each do |arg|
-        case
-        when arg.respond_to?(:to_str)  ; @file = arg.to_str
-        when arg.respond_to?(:to_int)  ; @line = arg.to_int
-        when arg.respond_to?(:to_hash) ; @options = arg.to_hash.dup
-        when arg.respond_to?(:path)    ; @file = arg.path
-        when arg.respond_to?(:to_path) ; @file = arg.to_path
-        else raise TypeError, "Can't load the template file. Pass a string with a path " +
-          "or an object that responds to 'to_str', 'path' or 'to_path'"
-        end
-      end
-
-      raise ArgumentError, "file or block required" if (@file || block).nil?
-
-      # used to hold compiled template methods
-      @compiled_method = {}
-
-      # used on 1.9 to set the encoding if it is not set elsewhere (like a magic comment)
-      # currently only used if template compiles to ruby
-      @default_encoding = @options.delete :default_encoding
-
-      # load template data and prepare (uses binread to avoid encoding issues)
-      @reader = block || lambda { |t| read_template_file }
-      @data = @reader.call(self)
-
-      if @data.respond_to?(:force_encoding)
-        if default_encoding
-          @data = @data.dup if @data.frozen?
-          @data.force_encoding(default_encoding)
-        end
-
-        if !@data.valid_encoding?
-          raise Encoding::InvalidByteSequenceError, "#{eval_file} is not valid #{@data.encoding}"
-        end
-      end
-
-      prepare
-    end
-
-    # Render the template in the given scope with the locals specified. If a
-    # block is given, it is typically available within the template via
-    # +yield+.
-    def render(scope=nil, locals={}, &block)
-      scope ||= Object.new
-      current_template = Thread.current[:tilt_current_template]
-      Thread.current[:tilt_current_template] = self
-      evaluate(scope, locals || {}, &block)
-    ensure
-      Thread.current[:tilt_current_template] = current_template
-    end
-
-    # The basename of the template file.
-    def basename(suffix='')
-      File.basename(file, suffix) if file
-    end
-
-    # The template file's basename with all extensions chomped off.
-    def name
-      basename.split('.', 2).first if basename
-    end
-
-    # The filename used in backtraces to describe the template.
-    def eval_file
-      file || '(__TEMPLATE__)'
-    end
-
-    # An empty Hash that the template engine can populate with various
-    # metadata.
-    def metadata
-      if respond_to?(:allows_script?)
-        self.class.metadata.merge(:allows_script => allows_script?)
-      else
-        self.class.metadata
-      end
-    end
-
-    protected
-
-    # @!group For template implementations
-
-    # The encoding of the source data. Defaults to the
-    # default_encoding-option if present. You may override this method
-    # in your template class if you have a better hint of the data's
-    # encoding.
-    def default_encoding
-      @default_encoding
-    end
-
-    # Do whatever preparation is necessary to setup the underlying template
-    # engine. Called immediately after template data is loaded. Instance
-    # variables set in this method are available when #evaluate is called.
-    #
-    # Subclasses must provide an implementation of this method.
-    def prepare
-      raise NotImplementedError
-    end
-
-    # Execute the compiled template and return the result string. Template
-    # evaluation is guaranteed to be performed in the scope object with the
-    # locals specified and with support for yielding to the block.
-    #
-    # This method is only used by source generating templates. Subclasses that
-    # override render() may not support all features.
-    def evaluate(scope, locals, &block)
-      locals_keys = locals.keys
-      locals_keys.sort!{|x, y| x.to_s <=> y.to_s}
-      method = compiled_method(locals_keys, scope.is_a?(Module) ? scope : scope.class)
-      method.bind(scope).call(locals, &block)
-    end
-
-    # Generates all template source by combining the preamble, template, and
-    # postamble and returns a two-tuple of the form: [source, offset], where
-    # source is the string containing (Ruby) source code for the template and
-    # offset is the integer line offset where line reporting should begin.
-    #
-    # Template subclasses may override this method when they need complete
-    # control over source generation or want to adjust the default line
-    # offset. In most cases, overriding the #precompiled_template method is
-    # easier and more appropriate.
-    def precompiled(local_keys)
-      preamble = precompiled_preamble(local_keys)
-      template = precompiled_template(local_keys)
-      postamble = precompiled_postamble(local_keys)
-      source = String.new
-
-      # Ensure that our generated source code has the same encoding as the
-      # the source code generated by the template engine.
-      if source.respond_to?(:force_encoding)
-        template_encoding = extract_encoding(template)
-
-        source.force_encoding(template_encoding)
-        template.force_encoding(template_encoding)
-      end
-
-      source << preamble << "\n" << template << "\n" << postamble
-
-      [source, preamble.count("\n")+1]
-    end
-
-    # A string containing the (Ruby) source code for the template. The
-    # default Template#evaluate implementation requires either this
-    # method or the #precompiled method be overridden. When defined,
-    # the base Template guarantees correct file/line handling, locals
-    # support, custom scopes, proper encoding, and support for template
-    # compilation.
-    def precompiled_template(local_keys)
-      raise NotImplementedError
-    end
-
-    def precompiled_preamble(local_keys)
-      ''
-    end
-
-    def precompiled_postamble(local_keys)
-      ''
-    end
-
-    # !@endgroup
-
-    private
-
-    def read_template_file
-      data = File.open(file, 'rb') { |io| io.read }
-      if data.respond_to?(:force_encoding)
-        # Set it to the default external (without verifying)
-        data.force_encoding(Encoding.default_external) if Encoding.default_external
-      end
-      data
-    end
-
-    # The compiled method for the locals keys provided.
-    def compiled_method(locals_keys, scope_class=nil)
-      LOCK.synchronize do
-        @compiled_method[[scope_class, locals_keys]] ||= compile_template_method(locals_keys, scope_class)
-      end
-    end
-
-    def local_extraction(local_keys)
-      local_keys.map do |k|
-        if k.to_s =~ /\A[a-z_][a-zA-Z_0-9]*\z/
-          "#{k} = locals[#{k.inspect}]"
-        else
-          raise "invalid locals key: #{k.inspect} (keys must be variable names)"
-        end
-      end.join("\n")
-    end
-
-    def compile_template_method(local_keys, scope_class=nil)
-      source, offset = precompiled(local_keys)
-      local_code = local_extraction(local_keys)
-
-      method_name = "__tilt_#{Thread.current.object_id.abs}"
-      method_source = String.new
-
-      if method_source.respond_to?(:force_encoding)
-        method_source.force_encoding(source.encoding)
-      end
-
-      method_source << <<-RUBY
-        TOPOBJECT.class_eval do
-          def #{method_name}(locals)
-            #{local_code}
-      RUBY
-      offset += method_source.count("\n")
-      method_source << source
-      method_source << "\nend;end;"
-      (scope_class || Object).class_eval(method_source, eval_file, line - offset)
-      unbind_compiled_method(method_name)
-    end
-
-    def unbind_compiled_method(method_name)
-      method = TOPOBJECT.instance_method(method_name)
-      TOPOBJECT.class_eval { remove_method(method_name) }
-      method
-    end
-
-    def extract_encoding(script)
-      extract_magic_comment(script) || script.encoding
-    end
-
-    def extract_magic_comment(script)
-      binary(script) do
-        script[/\A[ \t]*\#.*coding\s*[=:]\s*([[:alnum:]\-_]+).*$/n, 1]
-      end
-    end
-
-    def binary(string)
-      original_encoding = string.encoding
-      string.force_encoding(Encoding::BINARY)
-      yield
-    ensure
-      string.force_encoding(original_encoding)
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/tilt-2.0.10/lib/tilt/typescript.rb

@@ -1,26 +0,0 @@
-require 'tilt/template'
-require 'typescript-node'
-
-module Tilt
-  class TypeScriptTemplate < Template
-    self.default_mime_type = 'application/javascript'
-
-    def prepare
-      @option_args = []
-
-      options.each do |key, value|
-        next unless value
-
-        @option_args << "--#{key}"
-
-        if value != true
-          @option_args << value.to_s
-        end
-      end
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= TypeScript::Node.compile(data, *@option_args)
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/tilt-2.0.10/lib/tilt/wikicloth.rb

@@ -1,22 +0,0 @@
-require 'tilt/template'
-require 'wikicloth'
-
-module Tilt
-  # WikiCloth implementation. See:
-  # http://redcloth.org/
-  class WikiClothTemplate < Template
-    def prepare
-      @parser = options.delete(:parser) || WikiCloth::Parser
-      @engine = @parser.new options.merge(:data => data)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/tilt-2.0.10/lib/tilt/yajl.rb

@@ -1,87 +0,0 @@
-require 'tilt/template'
-require 'yajl'
-
-module Tilt
-
-  # Yajl Template implementation
-  #
-  # Yajl is a fast JSON parsing and encoding library for Ruby
-  # See https://github.com/brianmario/yajl-ruby
-  #
-  # The template source is evaluated as a Ruby string,
-  # and the result is converted #to_json.
-  #
-  # == Example
-  #
-  #    # This is a template example.
-  #    # The template can contain any Ruby statement.
-  #    tpl <<-EOS
-  #      @counter = 0
-  #
-  #      # The json variable represents the buffer
-  #      # and holds the data to be serialized into json.
-  #      # It defaults to an empty hash, but you can override it at any time.
-  #      json = {
-  #        :"user#{@counter += 1}" => { :name => "Joshua Peek", :id => @counter },
-  #        :"user#{@counter += 1}" => { :name => "Ryan Tomayko", :id => @counter },
-  #        :"user#{@counter += 1}" => { :name => "Simone Carletti", :id => @counter },
-  #      }
-  #
-  #      # Since the json variable is a Hash,
-  #      # you can use conditional statements or any other Ruby statement
-  #      # to populate it.
-  #      json[:"user#{@counter += 1}"] = { :name => "Unknown" } if 1 == 2
-  #
-  #      # The last line doesn't affect the returned value.
-  #      nil
-  #    EOS
-  #
-  #    template = Tilt::YajlTemplate.new { tpl }
-  #    template.render(self)
-  #
-  class YajlTemplate < Template
-
-    self.default_mime_type = 'application/json'
-
-    def prepare
-    end
-
-    def evaluate(scope, locals, &block)
-      decorate super(scope, locals, &block)
-    end
-
-    def precompiled_preamble(locals)
-      return super if locals.include? :json
-      "json = {}\n#{super}"
-    end
-
-    def precompiled_postamble(locals)
-      "Yajl::Encoder.new.encode(json)"
-    end
-
-    def precompiled_template(locals)
-      data.to_str
-    end
-
-
-    # Decorates the +json+ input according to given +options+.
-    #
-    # json    - The json String to decorate.
-    # options - The option Hash to customize the behavior.
-    #
-    # Returns the decorated String.
-    def decorate(json)
-      callback, variable = options[:callback], options[:variable]
-      if callback && variable
-        "var #{variable} = #{json}; #{callback}(#{variable});"
-      elsif variable
-        "var #{variable} = #{json};"
-      elsif callback
-        "#{callback}(#{json});"
-      else
-        json
-      end
-    end
-  end
-
-end