RubyGems - brakeman - Versions diffs - 7.1.2 → 8.0.0 - Mend

brakeman 7.1.2 → 8.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (130) hide show

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/haml.rb RENAMED Viewed

@@ -1,4 +1,70 @@
 # frozen_string_literal: true
+# = Haml (<tt>haml</tt>)
+#
+# {Haml}[https://haml.info] is a markup language that’s used to cleanly and simply describe
+# the HTML of any web document without the use of inline code. Haml functions as
+# a replacement for inline page templating systems such as PHP, ASP, and ERB, the
+# templating language used in most Ruby on Rails applications. However, Haml
+# avoids the need for explicitly coding HTML into the template, because it itself
+# is a description of the HTML, with some code to generate dynamic content.
+# ({more}[http://haml.info/about.html)]
+#
+# === Example
+#
+#     %html
+#       %head
+#         %title= @title
+#       %body
+#         %h1
+#           Hello
+#           = world + '!'
+#
+# === Usage
+#
+# The <tt>Tilt::HamlTemplate</tt> class is registered for all files ending in <tt>.haml</tt>
+# by default. Haml templates support custom evaluation scopes and locals:
+#
+#     >> require 'haml'
+#     >> template = Tilt.new('hello.haml')
+#     => #<Tilt::HamlTemplate @file='hello.haml'>
+#     >> @title = "Hello Haml!"
+#     >> template.render(self, :world => 'Haml!')
+#     => "
+#     <html>
+#       <head>
+#         <title>Hello Haml!</title>
+#       </head>
+#       <body>
+#         <h1>Hello Haml!</h1>
+#       </body>
+#     </html>"
+#
+# Or, use the <tt>Tilt::HamlTemplate</tt> class directly to process strings:
+#
+#     >> require 'haml'
+#     >> template = Tilt::HamlTemplate.new { "%h1= 'Hello Haml!'" }
+#     => #<Tilt::HamlTemplate @file=nil ...>
+#     >> template.render
+#     => "<h1>Hello Haml!</h1>"
+#
+# __NOTE:__ It's suggested that your program <tt>require 'haml'</tt> at load time when
+# using this template engine within a threaded environment.
+#
+# === Options
+#
+# Please see the {Haml Reference}[http://haml.info/docs/yardoc/file.HAML_REFERENCE.html#options] for all available options.
+#
+# === See also
+#
+# * {#haml.docs}[http://haml.info/docs.html]
+# * {Haml Tutorial}[http://haml.info/tutorial.html]
+# * {Haml Reference}[http://haml.info/docs/yardoc/file.HAML_REFERENCE.html]
+#
+# === Related module
+#
+# * Tilt::HamlTemplate
 require_relative 'template'
 require 'haml'
@@ -12,7 +78,7 @@ module Tilt
     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.
+      # <tt>Gem::Version.correct?</tt> 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[:filename] = eval_file

data/bundle/ruby/3.2.0/gems/tilt-2.7.0/lib/tilt/kramdown.rb ADDED Viewed

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+# = Markdown (<tt>markdown</tt>, <tt>md</tt>, <tt>mkd</tt>)
+#
+# Markdown is a lightweight markup language, created by John Gruber
+# and Aaron Swartz. For any markup that is not covered by Markdown’s syntax, HTML
+# is used.  Marking up plain text with Markdown markup is easy and Markdown
+# formatted texts are readable.
+#
+# === Example
+#
+#     Hello Markdown Templates
+#     ========================
+#
+#     Hello World. This is a paragraph.
+#
+# === Usage
+#
+# To wrap a Markdown formatted document with a layout:
+#
+#     layout = Tilt['erb'].new do
+#       "<!doctype html><title></title><%= yield %>"
+#     end
+#     data = Tilt['md'].new { "# hello tilt" }
+#     layout.render { data.render }
+#     # => "<!doctype html><title></title><h1>hello tilt</h1>\n"
+#
+# === Options
+#
+# Every implementation of Markdown *should* support these options, but there are
+# some known problems with the Kramdown engine.
+#
+# ==== <tt>:smartypants => true|false</tt>
+#
+# Set <tt>true</tt> to enable [Smarty Pants][smartypants] style punctuation replacement.
+#
+# In Kramdown this option only applies to smart quotes. It will apply a
+# subset of Smarty Pants (e.g. <tt>...</tt> to <tt>…</tt>) regardless of any option.
+#
+# ==== <tt>:escape_html => true|false</tt>
+#
+# Kramdown doesn't support this option.
+#
+# === See also
+#
+# * {Markdown Syntax Documentation}[http://daringfireball.net/projects/markdown/syntax]
+# * {Kramdown Markdown implementation}[https://kramdown.gettalong.org]
+require_relative 'template'
+require 'kramdown'
+dumb_quotes = [39, 39, 34, 34].freeze
+Tilt::KramdownTemplate = Tilt::StaticTemplate.subclass do
+  # dup as Krawmdown modifies the passed option with map!
+  @options[:smart_quotes] = dumb_quotes.dup unless @options[:smartypants]
+  Kramdown::Document.new(@data, @options).to_html
+end

data/bundle/ruby/3.2.0/gems/tilt-2.7.0/lib/tilt/liquid.rb ADDED Viewed

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+# = Liquid (<tt>liquid</tt>)
+#
+# Liquid is designed to be a *safe* template system and therefore
+# does not provide direct access to execuatable scopes. In order to
+# support a +scope+, the +scope+ must be able to represent itself
+# as a hash by responding to #to_h. If the +scope+ does not respond
+# to #to_h it will be ignored.
+#
+# LiquidTemplate does not support yield blocks.
+#
+# === Example
+#
+#     <html>
+#       <head>
+#         <title>{{ title }}</title>
+#       </head>
+#       <body>
+#         <h1>Hello {{ world }}!</h1>
+#       </body>
+#     </html>
+#
+# === Usage
+#
+# <tt>Tilt::LiquidTemplate</tt> is registered for all files ending in <tt>.liquid</tt> by
+# default. Liquid templates support locals and objects that respond to
+# <tt>#to_h</tt> as scopes:
+#
+#     >> require 'liquid'
+#     >> require 'tilt'
+#     >> template = Tilt.new('hello.liquid')
+#     => #<Tilt::LiquidTemplate @file='hello.liquid'>
+#     >> scope = { :title => "Hello Liquid Templates" }
+#     >> template.render(nil, :world => "Liquid")
+#     => "
+#     <html>
+#       <head>
+#         <title>Hello Liquid Templates</title>
+#       </head>
+#       <body>
+#         <h1>Hello Liquid!</h1>
+#       </body>
+#     </html>"
+#
+# Or, use <tt>Tilt::LiquidTemplate</tt> directly to process strings:
+#
+#     >> require 'liquid'
+#     >> template = Tilt::LiquidTemplate.new { "<h1>Hello Liquid!</h1>" }
+#     => #<Tilt::LiquidTemplate @file=nil ...>
+#     >> template.render
+#     => "<h1>Hello Liquid!</h1>"
+#
+# __NOTE:__ It's suggested that your program <tt>require 'liquid'</tt> at load
+# time when using this template engine within a threaded environment.
+#
+# === See also
+#
+# * {Liquid}[http://liquidmarkup.org]
+# * {Liquid for Programmers}[https://wiki.github.com/Shopify/liquid/liquid-for-programmers]
+# * {Liquid Docs}[http://liquid.rubyforge.org/]
+# * GitHub: {Shopify/liquid}[https://github.com/Shopify/liquid/]
+#
+# === Related module
+#
+# * Tilt::LiquidTemplate
+require_relative 'template'
+require 'liquid'
+module Tilt
+  class LiquidTemplate < Template
+    def prepare
+      @options[:line_numbers] = true unless @options.has_key?(:line_numbers)
+      @engine = ::Liquid::Template.parse(@data, @options)
+    end
+    def evaluate(scope, locs)
+      locals = {}
+      if scope.respond_to?(:to_h)
+        scope.to_h.each{|k, v| locals[k.to_s] = v}
+      end
+      locs.each{|k, v| locals[k.to_s] = v}
+      locals['yield'] = block_given? ? yield : ''
+      locals['content'] = locals['yield']
+      @engine.render(locals)
+    end
+    def allows_script?
+      false
+    end
+  end
+end

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/livescript.rb RENAMED Viewed

@@ -1,11 +1,18 @@
 # frozen_string_literal: true
-require_relative 'template'
-require 'livescript'
-# LiveScript template implementation. See:
-# http://livescript.net/
+# = LiveScript
+#
+# LiveScript template implementation.
 #
 # LiveScript templates do not support object scopes, locals, or yield.
+#
+# === See also
+#
+# * http://livescript.net
+require_relative 'template'
+require 'livescript'
 Tilt::LiveScriptTemplate = Tilt::StaticTemplate.subclass(mime_type: 'application/javascript') do
   LiveScript.compile(@data, @options)
 end

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/mapping.rb RENAMED Viewed

@@ -119,8 +119,8 @@ module Tilt
   #     # => RDiscount::Template
   #
   # In the previous example we say that RDiscount has a *higher priority* than
-  # Kramdown. Tilt will first try to `require "rdiscount/template"`, falling
-  # back to `require "kramdown/template"`. If none of these are successful,
+  # Kramdown. Tilt will first try to <tt>require "rdiscount/template"</tt>, falling
+  # back to <tt>require "kramdown/template"</tt>. If none of these are successful,
   # the first error will be raised.
   class Mapping < BaseMapping
     LOCK = Mutex.new
@@ -237,7 +237,7 @@ module Tilt
     #                             :templates=>['erb', 'scss'])
     def register_pipeline(ext, options=EMPTY_HASH)
       templates = options[:templates] || ext.split('.').reverse
-      templates = templates.map{|t| [self[t], options[t] || EMPTY_HASH]}
+      templates = templates.map{|t| [self[t], t, options[t] || EMPTY_HASH]}
       klass = Class.new(Pipeline)
       klass.send(:const_set, :TEMPLATES, templates)
@@ -346,13 +346,13 @@ module Tilt
     end
     # The proper behavior (in MRI) for autoload? is to
-    # return `false` when the constant/file has been
+    # return <tt>false</tt> when the constant/file has been
     # explicitly required.
     #
-    # However, in JRuby it returns `true` even after it's
-    # been required. In that case it turns out that `defined?`
-    # returns `"constant"` if it exists and `nil` when it doesn't.
-    # This is actually a second bug: `defined?` should resolve
+    # However, in JRuby it returns <tt>true</tt> even after it's
+    # been required. In that case it turns out that <tt>defined?</tt>
+    # returns <tt>"constant"</tt> if it exists and <tt>nil</tt> when it doesn't.
+    # This is actually a second bug: <tt>defined?</tt> should resolve
     # autoload (aka. actually try to require the file).
     #
     # We use the second bug in order to resolve the first bug.

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/markaby.rb RENAMED Viewed

@@ -1,10 +1,19 @@
 # frozen_string_literal: true
+# = Markaby
+#
+# === See also
+#
+# * http://github.com/markaby/markaby
+#
+# === Related module
+#
+# * Tilt::MarkabyTemplate
 require_relative 'template'
 require 'markaby'
 module Tilt
-  # Markaby
-  # http://github.com/markaby/markaby
   class MarkabyTemplate < Template
     def self.builder_class
       @builder_class ||= Class.new(Markaby::Builder) do

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/nokogiri.rb RENAMED Viewed

@@ -1,10 +1,21 @@
 # frozen_string_literal: true
+# = Nokogiri
+#
+# Nokogiri template implementation.
+#
+# === See also
+#
+# * http://nokogiri.org/
+#
+# === Related module
+#
+# * Tilt::NokogiriTemplate
 require_relative 'template'
 require 'nokogiri'
 module Tilt
-  # Nokogiri template implementation. See:
-  # http://nokogiri.org/
   class NokogiriTemplate < Template
     DOCUMENT_HEADER = /\A<\?xml version=\"1\.0\"\?>\n?/
     self.default_mime_type = 'text/xml'

data/bundle/ruby/3.2.0/gems/tilt-2.7.0/lib/tilt/pandoc.rb ADDED Viewed

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+# = Markdown (<tt>markdown</tt>, <tt>md</tt>, <tt>mkd</tt>)
+#
+# {Markdown}[http://daringfireball.net/projects/markdown/syntax] is a
+# lightweight markup language, created by John Gruber and Aaron Swartz.
+# For any markup that is not covered by Markdown’s syntax, HTML is used.
+# Marking up plain text with Markdown markup is easy and Markdown
+# formatted texts are readable.
+#
+# === Example
+#
+#     Hello Markdown Templates
+#     ========================
+#
+#     Hello World. This is a paragraph.
+#
+# === Usage
+#
+# To wrap a Markdown formatted document with a layout:
+#
+#     layout = Tilt['erb'].new do
+#       "<!doctype html><title></title><%= yield %>"
+#     end
+#     data = Tilt['md'].new { "# hello tilt" }
+#     layout.render { data.render }
+#     # => "<!doctype html><title></title><h1>hello tilt</h1>\n"
+#
+# === Options
+#
+# ==== <tt>:smartypants => true|false</tt>
+#
+# Set <tt>true</tt> to enable [Smarty Pants][smartypants] style punctuation replacement.
+#
+# ==== <tt>:escape_html => true|false</tt>
+#
+# Set <tt>true</tt> disallow raw HTML in Markdown contents. HTML is converted to
+# literal text by escaping <tt><</tt> characters.
+#
+# === See also
+#
+# * {Markdown Syntax Documentation}[http://daringfireball.net/projects/markdown/syntax]
+# * {Pandoc}[http://pandoc.org]
+require_relative 'template'
+require 'pandoc-ruby'
+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.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/pipeline.rb RENAMED Viewed

@@ -1,12 +1,17 @@
 # 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)|
+      @pipeline = self.class::TEMPLATES.inject(proc{|*| data}) do |data, (klass, ext, options)|
         proc do |s,l,&sb|
+          options = options
+          if ext_opts = @options[ext]
+            options = options.merge(ext_opts)
+          end
           klass.new(file, line, options, &proc{|*| data.call(s, l, &sb)}).render(s, l, &sb)
         end
       end

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/plain.rb RENAMED Viewed

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

data/bundle/ruby/3.2.0/gems/{tilt-2.6.1 → tilt-2.7.0}/lib/tilt/prawn.rb RENAMED Viewed

@@ -1,26 +1,37 @@
 # frozen_string_literal: true
+# = Prawn
+#
+# Prawn template implementation.
+#
+# === See also
+#
+# * http://prawnpdf.org
+#
+# === Related module
+#
+# * Tilt::PrawnTemplate
 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
+      pdf = ::Prawn::Document.new(@options)
       locals = locals.dup
       locals[:pdf] = pdf
       super
       pdf.render
     end
     def precompiled_template(locals)
       @data.to_str
     end

data/bundle/ruby/3.2.0/gems/tilt-2.7.0/lib/tilt/radius.rb ADDED Viewed

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+# = Radius (<tt>radius</tt>)
+#
+# {Radius}[http://radius.rubyforge.org] is the template language used by {Radiant CMS}[http://radiantcms.org]. It is
+# a tag language designed to be valid XML/HTML.
+#
+# === Example
+#
+#     <html>
+#     <body>
+#       <h1><r:title /></h1>
+#       <ul class="<r:type />">
+#       <r:repeat times="3">
+#         <li><r:hello />!</li>
+#       </r:repeat>
+#       </ul>
+#       <r:yield />
+#     </body>
+#     </html>
+#
+# === Usage
+#
+# To render a template such as the one above.
+#
+#     scope = OpenStruct.new
+#     scope.title = "Radius Example"
+#     scope.hello = "Hello, World!"
+#
+#     require 'radius'
+#     template = Tilt::RadiusTemplate.new('example.radius', :tag_prefix=>'r')
+#     template.render(scope, :type=>'hlist'){ "Jackpot!" }
+#
+# The result will be:
+#
+#     <html>
+#     <body>
+#       <h1>Radius Example</h1>
+#       <ul class="hlist">
+#         <li>Hello, World!</li>
+#         <li>Hello, World!</li>
+#         <li>Hello, World!</li>
+#       </ul>
+#       Jackpot!
+#     </body>
+#     </html>
+#
+# === See also
+#
+# * {Radius}[http://radius.rubyforge.org]
+# * {Radiant CMS}[http://radiantcms.org]
+#
+# === Related module
+#
+# * Tilt::RadiusTemplate
+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.2.0/gems/tilt-2.7.0/lib/tilt/rdiscount.rb ADDED Viewed

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+# = RDiscount (<tt>markdown</tt>, <tt>md</tt>, <tt>mkd</tt>)
+#
+# Markdown is a lightweight markup language, created by John Gruber
+# and Aaron Swartz. For any markup that is not covered by Markdown’s syntax, HTML
+# is used.  Marking up plain text with Markdown markup is easy and Markdown
+# formatted texts are readable.
+#
+# 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.
+#
+# === Example
+#
+#     Hello Markdown Templates
+#     ========================
+#
+#     Hello World. This is a paragraph.
+#
+# === Usage
+#
+# To wrap a Markdown formatted document with a layout:
+#
+#     layout = Tilt['erb'].new do
+#       "<!doctype html><title></title><%= yield %>"
+#     end
+#     data = Tilt['md'].new { "# hello tilt" }
+#     layout.render { data.render }
+#     # => "<!doctype html><title></title><h1>hello tilt</h1>\n"
+#
+# === Options
+#
+# ==== <tt>:smartypants => true|false</tt>
+#
+# Set <tt>true</tt> to enable [Smarty Pants][smartypants] style punctuation replacement.
+#
+# ==== <tt>:escape_html => true|false</tt>
+#
+# Set <tt>true</tt> disallow raw HTML in Markdown contents. HTML is converted to
+# literal text by escaping <tt><</tt> characters.
+#
+# === See also
+#
+#  * {Markdown Syntax Documentation}[http://daringfireball.net/projects/markdown/syntax]
+#  * [Discount][discount]
+#  * {RDiscount}[http://github.com/rtomayko/rdiscount]
+#
+# -----------------------------------
+#
+# [Discount][discount] is an implementation of the Markdown markup language in C.
+# [RDiscount][rdiscount] is a Ruby wrapper around Discount.
+#
+# All the documentation of {Markdown}[#markdown] applies in addition to the following:
+#
+# === Usage
+#
+# The <tt>Tilt::RDiscountTemplate</tt> class is registered for all files ending in
+# <tt>.markdown</tt>, <tt>.md</tt> or <tt>.mkd</tt> by default with the highest priority. If you
+# specifically want to use RDiscount, it's recommended to use <tt>#prefer</tt>:
+#
+#     Tilt.prefer Tilt::RDiscountTemplate
+#
+# __NOTE:__ It's suggested that your program <tt>require 'rdiscount'</tt> at load time when
+# using this template engine within a threaded environment.
+require_relative 'template'
+require 'rdiscount'
+aliases = {
+  :escape_html => :filter_html,
+  :smartypants => :smart
+}.freeze
+_flags = [:smart, :filter_html, :smartypants, :escape_html].freeze
+Tilt::RDiscountTemplate = Tilt::StaticTemplate.subclass do
+  flags = _flags.select { |flag| @options[flag] }.
+    map! { |flag| aliases[flag] || flag }
+  RDiscount.new(@data, *flags).to_html
+end