brakeman 6.1.1 → 6.2.0

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/haml.rb

@@ -1,86 +0,0 @@
-require 'tilt/template'
-require 'haml'
-
-module Tilt
-  # Haml template implementation. See:
-  # http://haml.hamptoncatlin.com/
-  class HamlTemplate < Template
-    self.default_mime_type = 'text/html'
-
-    # `Gem::Version.correct?` may return false because of Haml::VERSION #=> "3.1.8 (Separated Sally)". After Haml 4, it's always correct.
-    if Gem::Version.correct?(Haml::VERSION) && Gem::Version.new(Haml::VERSION) >= Gem::Version.new('5.0.0.beta.2')
-      def prepare
-        options = {}.update(@options).update(filename: eval_file, line: line)
-        if options.include?(:outvar)
-          options[:buffer] = options.delete(:outvar)
-          options[:save_buffer] = true
-        end
-        @engine = ::Haml::TempleEngine.new(options)
-        @engine.compile(data)
-      end
-
-      def evaluate(scope, locals, &block)
-        raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
-        super
-      end
-
-      def precompiled_template(locals)
-        @engine.precompiled_with_ambles(
-          [],
-          after_preamble: <<-RUBY
-            __in_erb_template = true
-            _haml_locals = locals
-          RUBY
-        )
-      end
-    else # Following definitions are for Haml <= 4 and deprecated.
-      def prepare
-        options = @options.merge(:filename => eval_file, :line => line)
-        @engine = ::Haml::Engine.new(data, options)
-      end
-
-      def evaluate(scope, locals, &block)
-        raise ArgumentError, 'invalid scope: must not be frozen' if scope.frozen?
-
-        if @engine.respond_to?(:precompiled_method_return_value, true)
-          super
-        else
-          @engine.render(scope, locals, &block)
-        end
-      end
-
-      # Precompiled Haml source. Taken from the precompiled_with_ambles
-      # method in Haml::Precompiler:
-      # http://github.com/nex3/haml/blob/master/lib/haml/precompiler.rb#L111-126
-      def precompiled_template(locals)
-        @engine.precompiled
-      end
-
-      def precompiled_preamble(locals)
-        local_assigns = super
-        @engine.instance_eval do
-          <<-RUBY
-            begin
-              extend Haml::Helpers
-              _hamlout = @haml_buffer = Haml::Buffer.new(haml_buffer, #{options_for_buffer.inspect})
-              _erbout = _hamlout.buffer
-              __in_erb_template = true
-              _haml_locals = locals
-              #{local_assigns}
-          RUBY
-        end
-      end
-
-      def precompiled_postamble(locals)
-        @engine.instance_eval do
-          <<-RUBY
-              #{precompiled_method_return_value}
-            ensure
-              @haml_buffer = @haml_buffer.upper if haml_buffer
-            end
-          RUBY
-        end
-      end
-    end
-  end
-end

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/kramdown.rb

@@ -1,25 +0,0 @@
-require 'tilt/template'
-require 'kramdown'
-
-module Tilt
-  # Kramdown Markdown implementation. See:
-  # http://kramdown.rubyforge.org/
-  class KramdownTemplate < Template
-    DUMB_QUOTES = [39, 39, 34, 34]
-
-    def prepare
-      options[:smart_quotes] = DUMB_QUOTES unless options[:smartypants]
-      @engine = Kramdown::Document.new(data, options)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end
-

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/less.rb

@@ -1,30 +0,0 @@
-require 'tilt/template'
-require 'less'
-
-module Tilt
-  # Lessscss template implementation. See:
-  # http://lesscss.org/
-  #
-  # Less templates do not support object scopes, locals, or yield.
-  class LessTemplate < Template
-    self.default_mime_type = 'text/css'
-
-    def prepare
-      if ::Less.const_defined? :Engine
-        @engine = ::Less::Engine.new(data)
-      else
-        parser  = ::Less::Parser.new(options.merge :filename => eval_file, :line => line)
-        @engine = parser.parse(data)
-      end
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_css(options)
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end
-

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/livescript.rb

@@ -1,23 +0,0 @@
-require 'tilt/template'
-require 'livescript'
-
-module Tilt
-  # LiveScript template implementation. See:
-  # http://livescript.net/
-  #
-  # LiveScript templates do not support object scopes, locals, or yield.
-  class LiveScriptTemplate < Template
-    self.default_mime_type = 'application/javascript'
-
-    def prepare
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= LiveScript.compile(data, options)
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/maruku.rb

@@ -1,22 +0,0 @@
-require 'tilt/template'
-require 'maruku'
-
-module Tilt
-  # Maruku markdown implementation. See:
-  # http://maruku.rubyforge.org/
-  class MarukuTemplate < Template
-    def prepare
-      @engine = Maruku.new(data, options)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end
-

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/pandoc.rb

@@ -1,57 +0,0 @@
-require 'tilt/template'
-require 'pandoc-ruby'
-
-module Tilt
-  # Pandoc markdown implementation. See:
-  # http://pandoc.org/
-  class PandocTemplate < Template
-    self.default_mime_type = 'text/html'
-
-    # 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
-    def pandoc_options
-      result = []
-      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
-            result << k
-          when false
-            # do nothing
-          else
-            result << { k => v }
-          end
-        end
-      end
-      result << { :f => from + smart_extension }
-      result
-    end
-
-    def prepare
-      @engine = PandocRuby.new(data, *pandoc_options)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html.strip
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/plain.rb

@@ -1,16 +0,0 @@
-require 'tilt/template'
-
-
-module Tilt
-  # Raw text (no template functionality).
-  class PlainTemplate < Template
-    self.default_mime_type = 'text/html'
-
-    def prepare
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= data
-    end
-  end
-end

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/prawn.rb

@@ -1,43 +0,0 @@
-require 'tilt/template'
-require 'prawn'
-
-module Tilt
-  # Prawn template implementation. See: http://prawnpdf.org
-  #
-  class PrawnTemplate < Template
-    self.default_mime_type = 'application/pdf'
-    
-    def prepare
-      @engine = ::Prawn::Document.new(prawn_options)
-    end
-    
-    def evaluate(scope, locals, &block)
-      pdf = @engine
-      if data.respond_to?(:to_str)
-        locals[:pdf] = pdf
-        super(scope, locals, &block)
-      elsif data.kind_of?(Proc)
-        data.call(pdf)
-      end
-      @output ||= pdf.render
-    end
-    
-    def allows_script?
-      false
-    end
-    
-    def precompiled_template(locals)
-      data.to_str
-    end
-    
-    
-    private
-      
-      def prawn_options
-        # defaults to A4 instead of crazy US Letter format. 
-        { :page_size => "A4", :page_layout => :portrait }.merge(options)
-      end
-      
-  end
-  
-end

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/radius.rb

@@ -1,48 +0,0 @@
-require 'tilt/template'
-require 'radius'
-
-module Tilt
-  # Radius Template
-  # http://github.com/jlong/radius/
-  class RadiusTemplate < Template
-    def self.context_class
-      @context_class ||= Class.new(Radius::Context) do
-        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
-    end
-
-    def prepare
-    end
-
-    def evaluate(scope, locals, &block)
-      context = self.class.context_class.new
-      context.tilt_scope = scope
-      context.define_tag("yield") do
-        block.call
-      end
-      locals.each do |tag, value|
-        context.define_tag(tag) do
-          value
-        end
-      end
-
-      options = {:tag_prefix => 'r'}.merge(@options)
-      parser = Radius::Parser.new(context, options)
-      parser.parse(data)
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/rdiscount.rb

@@ -1,39 +0,0 @@
-require 'tilt/template'
-require 'rdiscount'
-
-module Tilt
-  # 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.
-  class RDiscountTemplate < 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 = RDiscount.new(data, *flags)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end
-

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/rdoc.rb

@@ -1,40 +0,0 @@
-require 'tilt/template'
-require 'rdoc'
-require 'rdoc/markup'
-require 'rdoc/markup/to_html'
-
-module Tilt
-  # RDoc template. See:
-  # http://rdoc.rubyforge.org/
-  #
-  # It's suggested that your program `require 'rdoc/markup'` and
-  # `require 'rdoc/markup/to_html'` at load time when using this template
-  # engine in a threaded environment.
-  class RDocTemplate < Template
-    self.default_mime_type = 'text/html'
-
-    def markup
-      begin
-        # RDoc 4.0
-        require 'rdoc/options'
-        RDoc::Markup::ToHtml.new(RDoc::Options.new, nil)
-      rescue ArgumentError
-        # RDoc < 4.0
-        RDoc::Markup::ToHtml.new
-      end
-    end
-
-    def prepare
-      @engine = markup.convert(data)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_s
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/redcarpet.rb

@@ -1,86 +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
-    superclass = Redcarpet2Template
-  else
-    superclass = Redcarpet1Template
-  end
-
-  class RedcarpetTemplate < superclass
-  end
-end
-

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/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/3.0.0/gems/tilt-2.0.11/lib/tilt/rst-pandoc.rb

@@ -1,23 +0,0 @@
-require 'tilt/template'
-require 'pandoc'
-
-module Tilt
-  # Pandoc reStructuredText implementation. See:
-  # http://pandoc.org/
-  class RstPandocTemplate < PandocTemplate
-    self.default_mime_type = 'text/html'
-
-    def prepare
-      @engine = PandocRuby.new(data, :f => "rst")
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html.strip
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/lib/tilt/sass.rb

@@ -1,78 +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 'sass-embedded'
-      require 'uri'
-      Engine = nil
-    rescue LoadError => err
-      begin
-        require 'sassc'
-        Engine = ::SassC::Engine
-      rescue LoadError
-        begin
-          require 'sass'
-          Engine = ::Sass::Engine
-        rescue LoadError
-          raise err
-        end
-      end
-    end
-
-    def prepare
-      @engine = unless Engine.nil?
-                  Engine.new(data, sass_options)
-                end
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= if @engine.nil?
-                    ::Sass.compile_string(data, **sass_embedded_options).css
-                  else
-                    @engine.render
-                  end
-    end
-
-    def allows_script?
-      false
-    end
-
-  private
-    def eval_file_url
-      path = File.absolute_path(eval_file)
-      path = '/' + path unless path.start_with?('/')
-      ::URI::File.build([nil, ::URI::DEFAULT_PARSER.escape(path)]).to_s
-    end
-
-    def sass_embedded_options
-      options.merge(:url => eval_file_url, :syntax => :indented)
-    end
-
-    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_embedded_options
-      options.merge(:url => eval_file_url, :syntax => :scss)
-    end
-
-    def sass_options
-      options.merge(:filename => eval_file, :line => line, :syntax => :scss)
-    end
-  end
-
-end
-

data/bundle/ruby/3.0.0/gems/tilt-2.0.11/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