brakeman 6.1.1 → 6.2.0

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/pandoc.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'pandoc-ruby'
+
+# Pandoc markdown implementation. See: http://pandoc.org/
+Tilt::PandocTemplate = Tilt::StaticTemplate.subclass do
+  # turn options hash into an array
+  # Map tilt options to pandoc options
+  # Replace hash keys with value true with symbol for key
+  # Remove hash keys with value false
+  # Leave other hash keys untouched
+  pandoc_options = []
+  from = "markdown"
+  smart_extension = "-smart"
+  @options.each do |k,v|
+    case k
+    when :smartypants
+      smart_extension = "+smart" if v
+    when :escape_html
+      from = "markdown-raw_html" if v
+    when :commonmark
+      from = "commonmark" if v
+    when :markdown_strict
+      from = "markdown_strict" if v
+    else
+      case v
+      when true
+        pandoc_options << k
+      when false
+        # do nothing
+      else
+        pandoc_options << { k => v }
+      end
+    end
+  end
+  pandoc_options << { :f => from + smart_extension }
+
+  PandocRuby.new(@data, *pandoc_options).to_html.strip
+end

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/pipeline.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+require_relative 'template'
+
+module Tilt
+  # Superclass used for pipeline templates.  Should not be used directly.
+  class Pipeline < Template
+    def prepare
+      @pipeline = self.class::TEMPLATES.inject(proc{|*| data}) do |data, (klass, options)|
+        proc do |s,l,&sb|
+          klass.new(file, line, options, &proc{|*| data.call(s, l, &sb)}).render(s, l, &sb)
+        end
+      end
+    end
+
+    def evaluate(scope, locals, &block)
+      @pipeline.call(scope, locals, &block)
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/plain.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+require_relative 'template'
+
+# Raw text (no template functionality).
+Tilt::PlainTemplate = Tilt::StaticTemplate.subclass{@data}

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/prawn.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'prawn'
+
+module Tilt
+  # Prawn template implementation. See: http://prawnpdf.org
+  class PrawnTemplate < Template
+    self.default_mime_type = 'application/pdf'
+    
+    def prepare
+      @options[:page_size] = 'A4' unless @options.has_key?(:page_size)
+      @options[:page_layout] = :portrait unless @options.has_key?(:page_layout)
+      @engine = ::Prawn::Document.new(@options)
+    end
+    
+    def evaluate(scope, locals, &block)
+      pdf = @engine
+      locals = locals.dup
+      locals[:pdf] = pdf
+      super
+      pdf.render
+    end
+    
+    def precompiled_template(locals)
+      @data.to_str
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/radius.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'radius'
+
+module Tilt
+  # Radius Template
+  # http://github.com/jlong/radius/
+  class RadiusTemplate < Template
+    class ContextClass < Radius::Context
+      attr_accessor :tilt_scope
+
+      def tag_missing(name, attributes)
+        tilt_scope.__send__(name)
+      end
+
+      def dup
+        i = super
+        i.tilt_scope = tilt_scope
+        i
+      end
+    end
+
+    def evaluate(scope, locals, &block)
+      context = ContextClass.new
+      context.tilt_scope = scope
+      context.define_tag("yield", &block) if block
+      locals.each do |tag, value|
+        context.define_tag(tag) do
+          value
+        end
+      end
+
+      @options[:tag_prefix] = 'r' unless @options.has_key?(:tag_prefix)
+      Radius::Parser.new(context, @options).parse(@data)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/rdiscount.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'rdiscount'
+
+aliases = {
+  :escape_html => :filter_html,
+  :smartypants => :smart
+}.freeze
+
+_flags = [:smart, :filter_html, :smartypants, :escape_html].freeze
+
+# Discount Markdown implementation. See:
+# http://github.com/rtomayko/rdiscount
+#
+# RDiscount is a simple text filter. It does not support +scope+ or
+# +locals+. The +:smart+ and +:filter_html+ options may be set true
+# to enable those flags on the underlying RDiscount object.
+Tilt::RDiscountTemplate = Tilt::StaticTemplate.subclass do
+  flags = _flags.select { |flag| @options[flag] }.
+    map! { |flag| aliases[flag] || flag }
+
+  RDiscount.new(@data, *flags).to_html
+end

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/rdoc.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'rdoc'
+require 'rdoc/markup'
+require 'rdoc/markup/to_html'
+require 'rdoc/options'
+
+# RDoc template. See: https://github.com/ruby/rdoc
+#
+# It's suggested that your program run the following at load time when
+# using this templae engine in a threaded environment:
+#
+#   require 'rdoc'
+#   require 'rdoc/markup'
+#   require 'rdoc/markup/to_html'
+#   require 'rdoc/options'
+Tilt::RDocTemplate = Tilt::StaticTemplate.subclass do
+  RDoc::Markup::ToHtml.new(RDoc::Options.new, nil).convert(@data).to_s
+end

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/redcarpet.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'redcarpet'
+
+aliases = {:escape_html => :filter_html, :smartypants => :smart}.freeze
+
+Tilt::RedcarpetTemplate = Tilt::StaticTemplate.subclass do
+  aliases.each do |opt, aka|
+    if options.key?(aka) || !@options.key?(opt)
+      @options[opt] = @options.delete(aka)
+    end
+  end
+
+  # only raise an exception if someone is trying to enable :escape_html
+  @options.delete(:escape_html) unless @options[:escape_html]
+
+  renderer = @options.delete(:renderer) || ::Redcarpet::Render::HTML.new(@options)
+  if options.delete(:smartypants) && !(renderer.is_a?(Class) && renderer <= ::Redcarpet::Render::SmartyPants)
+    renderer = 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
+
+  Redcarpet::Markdown.new(renderer, @options).render(@data)
+end

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/redcloth.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'redcloth'
+
+# RedCloth implementation. See: https://github.com/jgarber/redcloth
+Tilt::RedClothTemplate = Tilt::StaticTemplate.subclass do
+  engine = RedCloth.new(@data)
+  @options.each  do |k, v|
+    m = :"#{k}="
+    engine.send(m, v) if engine.respond_to? m
+  end
+  engine.to_html
+end

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/rst-pandoc.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require_relative 'template'
+require_relative 'pandoc'
+
+rst = {:f => "rst"}.freeze
+
+# Pandoc reStructuredText implementation. See: # http://pandoc.org/
+Tilt::RstPandocTemplate = Tilt::StaticTemplate.subclass do
+  PandocRuby.new(@data, rst).to_html.strip
+end

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/sass.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require_relative 'template'
+
+module Tilt
+  # Sass template implementation for generating CSS. See: https://sass-lang.com/
+  #
+  # Sass templates do not support object scopes, locals, or yield.
+  class SassTemplate < StaticTemplate
+    self.default_mime_type = 'text/css'
+
+    begin
+      require 'sass-embedded'
+    # :nocov:
+      require 'uri'
+
+      ALLOWED_KEYS = (defined?(::Sass::Compiler) ? ::Sass::Compiler : ::Sass::Embedded).
+        instance_method(:compile_string).
+        parameters.
+        map{|k, v| v if k == :key}.
+        compact rescue nil
+      private_constant :ALLOWED_KEYS
+
+      private
+
+      def _prepare_output
+        ::Sass.compile_string(@data, **sass_options).css
+      end
+
+      def sass_options
+        path = File.absolute_path(eval_file)
+        path = '/' + path unless path.start_with?('/')
+        opts = @options.dup
+        opts[:url] = ::URI::File.build([nil, ::URI::DEFAULT_PARSER.escape(path)]).to_s
+        opts[:syntax] = :indented
+        opts.delete_if{|k| !ALLOWED_KEYS.include?(k)} if ALLOWED_KEYS
+        opts
+      end
+    rescue LoadError => err
+      begin
+        require 'sassc'
+        Engine = ::SassC::Engine
+      rescue LoadError
+        begin
+          require 'sass'
+          Engine = ::Sass::Engine
+        rescue LoadError
+          raise err
+        end
+      end
+
+      private
+
+      def _prepare_output
+        Engine.new(@data, sass_options).render
+      end
+
+      def sass_options
+        @options[:filename] = eval_file
+        @options[:line] = @line
+        @options[:syntax] = :sass
+        @options
+      end
+    # :nocov:
+    end
+  end
+
+  class ScssTemplate < SassTemplate
+    self.default_mime_type = 'text/css'
+
+    private
+
+    def sass_options
+      opts = super
+      opts[:syntax] = :scss
+      opts
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/tilt-2.4.0/lib/tilt/slim.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+require_relative 'template'
+require 'slim'
+
+Tilt::SlimTemplate = Slim::Template

data/bundle/ruby/{3.0.0/gems/tilt-2.0.11 → 3.1.0/gems/tilt-2.4.0}/lib/tilt/string.rb

@@ -1,12 +1,14 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative '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}")
+      hash = "TILT#{@data.hash.abs}"
+      @freeze_string_literals = !!@options[:freeze]
+      @code = String.new("<<#{hash}.chomp\n#{@data}\n#{hash}")
     end
 
     def precompiled_template(locals)
@@ -17,5 +19,9 @@ module Tilt
       source, offset = super
       [source, offset + 1]
     end
+
+    def freeze_string_literals?
+      @freeze_string_literals
+    end
   end
 end