brakeman 5.2.2 → 7.1.1

data/bundle/ruby/3.1.0/gems/temple-0.10.4/CHANGES

@@ -0,0 +1,302 @@
+0.10.4
+
+  * Fix Ruby 3.4 compatibility (#152)
+
+0.10.3
+
+  * Remove test files from the gem package (#146)
+  * Add DynamicMerger filter (#147)
+
+0.10.2
+
+  * Fix Sinatra capture_generator problem (#145)
+
+0.10.1
+
+  * Use specified :capture_generator for nested captures (#112, #144)
+  * Compatibility with frozen string literals
+
+0.10.0
+
+  * Regression: Revert changes to :capture_generator since 0.8.2 (#112, #113, #137)
+  * Regression: Ensure that output buffer is not reused for capturing in Rails (#135)
+  * Drop support for Rails 4.x
+
+0.9.1
+
+  * Fix Slim's error in AttributeMerger due to 0.9.0's :capture_generator (#137)
+  * Use specified :capture_generator for nested captures (#112)
+  * Fix Temple::ERB::Engine's <%= to not escape and <%== to escape expressions
+
+0.9.0
+
+  * Require Ruby 2.5+ (#131)
+  * Change default :capture_generator to self (#113)
+  * Improve compatibility with Rails 7.1 (#135)
+  * Support Rails 6.1's annotate_rendered_view_with_filenames
+    with Temple::Filters::Ambles (#134)
+  * Fix a crash in StringSplitter filter (#138)
+  * Fix a warning by Object#=~ since Ruby 2.6 (#129)
+  * Fix deprecated Tilt template mime type (#108)
+  * Stop using deprecated EscapeUtils from Temple::Utils (#136)
+
+0.8.2
+
+  * Support TruffleRuby in Temple::Filters::StaticAnalyzer (#127)
+  * Support TruffleRuby in Temple::Filters::StringSplitter (#127)
+
+0.8.1
+
+  * Stop relying on deprecated method in Rails (#121)
+  * Fix issue with --enable-frozen-string-literal
+  * Escape html in markdown
+
+0.8.0
+
+  * Add Temple::StaticAnalyzer to analyze Ruby expressions
+  * Support newlines in Temple::Filters::StaticAnalyzer
+
+0.7.8
+
+  * Fix a warning in StaticAnalyzer
+
+0.7.7
+
+  * Add Temple::Filters::StaticAnalyzer, Temple::Filters::StringSplitter
+  * Freeze string literals
+
+0.7.6
+
+  * EngineDSL - add support for use(:Filter) { FilterClassName }
+
+0.7.5
+
+  * HTML::Pretty Fix indentation issue (https://github.com/slim-template/slim-rails/issues/78)
+
+0.7.4
+
+  * EngineDSL: allow to replace/remove with regexp
+  * Fix deprecation warning (#83)
+
+0.7.3
+
+  * Temple::ERB::Trimming - replace option trim_mode with trim and switch to erubis-like trimming
+
+0.7.2
+
+  * Remove Filters::StaticFreezer, the generator does the freezing
+
+0.7.1
+
+  * Rename *Hash to *Map
+  * Add Filters::StaticFreezer
+
+0.7.0
+
+  * Drop Ruby 1.8.7 support
+  * EngineDSL: Remove option filter
+  * HTML: Deprecate :html4, :html5 formats
+  * HTML: Add format :xml
+  * Rename DefaultOptions to ClassOptions
+  * Deprecate default_options in favor of options
+  * Add Utils.indent_dynamic
+
+0.6.10
+
+  * Tilt template: Support :outvar and save/restore buffer to make the behaviour compatible with ERB
+
+0.6.9
+
+  * HTML::Pretty: Fix wrong line numbers
+  * Tilt template: Don't overwrite buffer always
+  * Generator: add preamble and postamble which do nothing
+  * Tilt template: don't overwrite streaming option
+  * OptionHash: inherit valid keys
+  * temple/html/safe: add poor man's html_safe? implementation (not required automatically)
+  * Temple::Mixins::GrammarDSL - Add some missing match? methods
+  * Temple::Utils.escape_html_safe - Add parameter safe
+
+0.6.8
+
+  * HTML::Fast add svg doctype
+  * Render standalone html 5 attributes
+
+0.6.7
+
+  * HTML::Pretty - change some block level tags
+  * Reduce memory allocations in immutable hash
+
+0.6.6
+
+  * Use default encoding utf-8
+  * Escape also '
+  * Try to load escape_utils by default
+
+0.6.5
+
+  * Added Filters::CodeMerger
+  * Added Filters::Encoding
+  * Added Filters::RemoveBOM
+  * Added Generators::ERB
+
+0.6.4
+
+  * Check for ActionView instead of Rails (#72)
+
+0.6.3
+
+  * Fix HTML escaping for HTML::Pretty (Issue #69)
+
+0.6.2
+
+  * [:html, :js, code] abstraction added
+
+0.6.1
+
+  * HTML::Pretty improved
+
+0.6.0
+
+  * HTML::AttributeMerger: rename option :attr_delimiter to :merge_attrs
+  * HTML: rename option :attr_wrapper to :attr_quote
+
+0.5.5
+
+  * HTML pretty: Do not remove empty lines, add newline after doctype
+
+0.5.4
+
+  * HTML::AttributeMerger fixed, it didn't remove first empty attribute values
+  * Add HTML::AttributeRemover back, :remove_empty_attrs must be an Array of Strings now
+    of the attributes to be removed if empty
+  * Simplify [:case] expression grammar
+  * Ignore parameter :outvar by sinatra since sinatra assumes also that the buffer is a String,
+    they should set :buffer and :generator explicitly if they need the access
+
+0.5.3
+
+  * Only print an message if invalid options are passed to Temple filters or engines
+    since many libraries seem to use Slim and Temple in an incorrect way
+
+0.5.2
+
+  * Fix the :outvar problem really
+
+0.5.1
+
+  * Support Sinatra :outvar option in Tilt template
+
+0.5.0
+
+  * Added exception Temple::FilterError which should be thrown by filters
+  * Added Temple::Parser as default base class for parsers
+  * escape_html doesn't escape / anymore
+  * HTML::AttributeSorter uses stable sorting now
+  * HTML::AttributeRemover removed (Was too Slim specific)
+  * Engine option :chain removed
+  * Option validation implemented (Use define_options in your filters)
+  * Deprecated options implemented (Use deprecated_options in your filters)
+  * ThreadOptions added, Method #with_options
+
+0.4.1
+
+  * Generators: produce optimized code
+  * remove deprecated method EngineDSL#wildcard
+  * Set tilt template default_mime_type to text/html
+  * HTML: Support conditional comments [:html, :condcomment, ...]
+
+0.4.0
+
+  * Split Temple::HTML::AttributeMerger in AttributeSorter,
+    AttributeMerger and AttributeRemover
+  * Fix issue #58
+
+0.3.5
+
+  * Temple::HTML::Pretty improved
+  * :sort_attrs option (default: true) added to HTML::AttributeMerger;
+    if set to false, the attributes will appear in the insertion order
+  * Temple::Mixins::EngineDSL api changed ("wildcard" is deprecated, use "use" instead)
+  * Temple::Mixins::CompiledDispatcher supports arbitrary levels now
+  * Don't use gsub! on incoming strings (#57)
+  * Fix newlines in erb parser (#46)
+
+0.3.4
+
+  * Bugfix release (0.3.3 was yanked)
+
+0.3.3
+
+  * Support for rails 3.1 streaming
+  * Add EngineDSL#wildcard
+  * HTML::Fast/Pretty supports only :xhtml and :html formats from now on
+  * HTML::AttributeMerger extracted from HTML::Fast
+
+0.3.1, 0.3.2
+
+  * Don't modify strings destructively with gsub! in HTML::Pretty.
+    This doesn't work with Rails safe buffers in version >= 3.0.8.
+
+0.3.0
+
+  * Compiled expression dispatching
+  * Method temple_dispatch is obsolete
+  * EscapeHTML renamed to Escapable
+  * Control flow filter added
+  * HTML filter: Tag and attribute expressions changed
+  * Expression grammar added
+  * Expression validator added
+  * Debugger filter removed (Validator is better replacement)
+
+0.2.0
+
+  * Add mutable/immutable hashes for option inheritance
+  * Rails template support added
+  * Rename Filter#compile to Filter#call
+  * Engine chain reconfiguration (append, prepend, replace, ...)
+  * HTML filter: Don't output empty attributes
+  * Escape expression changed [:escape, true/false, Expression]
+
+0.1.8
+
+  * HTML filter: Support :format => :html (alias for :html5)
+
+0.1.7
+
+  * HTML::Pretty indents dynamic content only if it doesn't contain
+    preformatted tags
+
+0.1.6
+
+  * Flexible chain building
+
+0.1.5
+
+  * Default options for engines
+
+0.1.4
+
+  * HTML::Pretty added
+  * Tilt-based template class added
+  * Escaping filter added
+  * Filter base class added
+  * Fix capturing (Issue #15)
+
+0.1.3
+
+  * Close issue #10
+  * Refactoring
+
+0.1.2
+
+  * Add HTML filter
+  * Remove Escapable filter
+  * Add method for checking if expression is empty
+
+0.1.1
+
+  * Test added
+
+0.1.0
+
+  * Initial release

data/bundle/ruby/3.1.0/gems/temple-0.10.4/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org/'
+gemspec

data/bundle/ruby/3.1.0/gems/temple-0.10.4/README.md

@@ -0,0 +1,267 @@
+Temple
+======
+
+[![test](https://github.com/judofyr/temple/actions/workflows/test.yml/badge.svg)](https://github.com/judofyr/temple/actions/workflows/test.yml) [![Code Climate](https://codeclimate.com/github/judofyr/temple.svg)](https://codeclimate.com/github/judofyr/temple) [![Gem Version](https://badge.fury.io/rb/temple.svg)](https://rubygems.org/gems/temple) [![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/gems/temple/frames)
+
+Temple is an abstraction and a framework for compiling templates to pure Ruby.
+It's all about making it easier to experiment, implement and optimize template
+languages. If you're interested in implementing your own template language, or
+anything else related to the internals of a template engine: You've come to
+the right place.
+
+Have a look around, and if you're still wondering: Ask on the mailing list and
+we'll try to do our best. In fact, it doesn't have to be related to Temple at
+all. As long as it has something to do with template languages, we're
+interested: <http://groups.google.com/group/guardians-of-the-temple>.
+
+Links
+-----
+
+* Source: <http://github.com/judofyr/temple>
+* Bugs:   <http://github.com/judofyr/temple/issues>
+* List:   <http://groups.google.com/group/guardians-of-the-temple>
+* API documentation:
+    * Latest Gem: <http://rubydoc.info/gems/temple/frames>
+    * GitHub master: <http://rubydoc.info/github/judofyr/temple/master/frames>
+* Abstractions: <http://github.com/judofyr/temple/blob/master/EXPRESSIONS.md>
+
+Overview
+--------
+
+Temple is built on a theory that every template consists of three elements:
+
+* Static text
+* Dynamic text (pieces of Ruby which are evaluated and sent to the client)
+* Codes (pieces of Ruby which are evaluated and *not* sent to the client, but
+  might change the control flow).
+
+The goal of a template engine is to take the template and eventually compile
+it into *the core abstraction*:
+
+```ruby
+ [:multi,
+   [:static, "Hello "],
+   [:dynamic, "@user.name"],
+   [:static, "!\n"],
+   [:code, "if @user.birthday == Date.today"],
+   [:static, "Happy birthday!"],
+   [:code, "end"]]
+```
+
+Then you can apply some optimizations, feed it to Temple and it generates fast
+Ruby code for you:
+
+```ruby
+ _buf = []
+ _buf << ("Hello #{@user.name}!\n")
+ if @user.birthday == Date.today
+   _buf << "Happy birthday!"
+ end
+ _buf.join
+```
+
+S-expression
+------------
+
+In Temple, an Sexp is simply an array (or a subclass) where the first element
+is the *type* and the rest are the *arguments*. The type must be a symbol and
+it's recommended to only use strings, symbols, arrays and numbers as
+arguments.
+
+Temple uses Sexps to represent templates because it's a simple and
+straightforward data structure, which can easily be written by hand and
+manipulated by computers.
+
+Some examples:
+
+```ruby
+ [:static, "Hello World!"]
+
+ [:multi,
+   [:static, "Hello "],
+   [:dynamic, "@world"]]
+
+ [:html, :tag, "em", [:html, :attrs], [:static, "Hey hey"]]
+```
+
+*NOTE:* SexpProcessor, a library written by Ryan Davis, includes a `Sexp`
+class. While you can use this class (since it's a subclass of Array), it's not
+what Temple mean by "Sexp".
+
+Abstractions
+------------
+
+The idea behind Temple is that abstractions are good, and it's better to have
+too many than too few. While you should always end up with the core
+abstraction, you shouldn't stress about it. Take one step at a time, and only
+do one thing at every step.
+
+So what's an abstraction? An abstraction is when you introduce a new types:
+
+```ruby
+ # Instead of:
+ [:static, "<strong>Use the force</strong>"]
+
+ # You use:
+ [:html, :tag, "strong", [:html, :attrs], [:static, "Use the force"]]
+```
+
+### Why are abstractions so important?
+
+First of all, it means that several template engines can share code. Instead
+of having two engines which goes all the way to generating HTML, you have two
+smaller engines which only compiles to the HTML abstraction together with
+something that compiles the HTML abstraction to the core abstraction.
+
+Often you also introduce abstractions because there's more than one way to do
+it. There's not a single way to generate HTML. Should it be indented? If so,
+with tabs or spaces? Or should it remove as much whitespace as possible?
+Single or double quotes in attributes? Escape all weird UTF-8 characters?
+
+With an abstraction you can easily introduce a completely new HTML compiler,
+and whatever is below doesn't have to care about it *at all*. They just
+continue to use the HTML abstraction. Maybe you even want to write your
+compiler in another language? Sexps are easily serialized and if you don't
+mind working across processes, it's not a problem at all.
+
+All abstractions used by Temple are documented in [EXPRESSIONS.md](EXPRESSIONS.md).
+
+Compilers
+---------
+
+A *compiler* is simply an object which responds a method called #call which
+takes one argument and returns a value. It's illegal for a compiler to mutate
+the argument, and it should be possible to use the same instance several times
+(although not by several threads at the same time).
+
+While a compiler can be any object, you very often want to structure it as a
+class. Temple then assumes the initializer takes an optional option hash:
+
+```ruby
+ class MyCompiler
+   def initialize(options = {})
+     @options = options
+   end
+
+   def call(exp)
+     # do stuff
+   end
+ end
+```
+
+### Parsers
+
+In Temple, a parser is also a compiler, because a compiler is just something
+that takes some input and produces some output. A parser is then something
+that takes a string and returns an Sexp.
+
+It's important to remember that the parser *should be dumb*. No optimization,
+no guesses. It should produce an Sexp that is as close to the source as
+possible. You should invent your own abstraction. Maybe you even want to
+separate the parsers into several parts and introduce several abstractions on
+the way?
+
+### Filters
+
+A filter is a compiler which take an Sexp and returns an Sexp. It might turn
+convert it one step closer to the core-abstraction, it might create a new
+abstraction, or it might just optimize in the current abstraction. Ultimately,
+it's still just a compiler which takes an Sexp and returns an Sexp.
+
+For instance, Temple ships with {Temple::Filters::DynamicInliner} and
+{Temple::Filters::StaticMerger} which are general optimization filters which
+works on the core abstraction.
+
+An HTML compiler would be a filter, since it would take an Sexp in the HTML
+abstraction and compile it down to the core abstraction.
+
+### Generators
+
+A generator is a compiler which takes an Sexp and returns a string which is
+valid Ruby code.
+
+Most of the time you would just use {Temple::Generators::ArrayBuffer} or any of the
+other generators in {Temple::Generators}, but nothing stops you from writing your
+own.
+
+In fact, one of the great things about Temple is that if you write a new
+generator which turns out to be a lot faster then the others, it's going to
+make *every single engine* based on Temple faster! So if you have any ideas,
+please share them - it's highly appreciated.
+
+Engines
+-------
+
+When you have a chain of a parsers, some filters and a generator you can finally create your *engine*. Temple provides {Temple::Engine} which makes this very easy:
+
+```ruby
+ class MyEngine < Temple::Engine
+   # First run MyParser
+   use MyParser
+
+   # Then a custom filter
+   use MyFilter
+
+   # Then some general optimizations filters
+   filter :MultiFlattener
+   filter :StaticMerger
+   filter :DynamicInliner
+
+   # Finally the generator
+   generator :ArrayBuffer
+ end
+
+ engine = MyEngine.new(strict: "For MyParser")
+ engine.call(something)
+```
+
+And then?
+---------
+
+You've ran the template through the parser, some filters and in the end a
+generator. What happens next?
+
+Temple provides helpers to create template classes for [Tilt](http://github.com/rtomayko/tilt) and
+Rails.
+
+```ruby
+ require 'tilt'
+
+ # Create template class MyTemplate and register your file extension
+ MyTemplate = Temple::Templates::Tilt(MyEngine, register_as: 'ext')
+
+ Tilt.new('example.ext').render     # => Render a file
+ MyTemplate.new { "String" }.render # => Render a string
+```
+
+Installation
+------------
+
+You need at least Ruby 1.9.3 to work with Temple. Temple is published as a Ruby Gem which can be installed
+as following:
+
+```bash
+ $ gem install temple
+```
+
+Engines using Temple
+--------------------
+
+* [Slim](https://github.com/slim-template/slim)
+* [Hamlit](https://github.com/k0kubun/hamlit)
+* [Faml](https://github.com/eagletmt/faml)
+* [Sal](https://github.com/stonean/sal.rb)
+* [Temple-Mustache (Example implementation)](https://github.com/minad/temple-mustache)
+* Temple ERB example implementation (Temple::ERB::Template)
+* [WLang](https://github.com/blambeau/wlang)
+
+Acknowledgements
+----------------
+
+Thanks to [_why](http://en.wikipedia.org/wiki/Why_the_lucky_stiff) for
+creating an excellent template engine (Markaby) which is quite slow. That's
+how I started experimenting with template engines in the first place.
+
+I also owe [Ryan Davis](http://zenspider.com/) a lot for his excellent
+projects ParserTree, RubyParser, Ruby2Ruby and SexpProcessor. Temple is
+heavily inspired by how these tools work.

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/engine.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+module Temple
+  # An engine is simply a chain of compilers (that often includes a parser,
+  # some filters and a generator).
+  #
+  #   class MyEngine < Temple::Engine
+  #     # First run MyParser, passing the :strict option
+  #     use MyParser, :strict
+  #
+  #     # Then a custom filter
+  #     use MyFilter
+  #
+  #     # Then some general optimizations filters
+  #     filter :MultiFlattener
+  #     filter :StaticMerger
+  #     filter :DynamicInliner
+  #
+  #     # Finally the generator
+  #     generator :ArrayBuffer, :buffer
+  #   end
+  #
+  #   class SpecialEngine < MyEngine
+  #     append MyCodeOptimizer
+  #     before :ArrayBuffer, Temple::Filters::Validator
+  #     replace :ArrayBuffer, Temple::Generators::RailsOutputBuffer
+  #   end
+  #
+  #   engine = MyEngine.new(strict: "For MyParser")
+  #   engine.call(something)
+  #
+  # @api public
+  class Engine
+    include Mixins::Options
+    include Mixins::EngineDSL
+    extend  Mixins::EngineDSL
+
+    define_options :file, :streaming, :buffer, :save_buffer
+
+    attr_reader :chain
+
+    def self.chain
+      @chain ||= superclass.respond_to?(:chain) ? superclass.chain.dup : []
+    end
+
+    def initialize(opts = {})
+      super
+      @chain = self.class.chain.dup
+    end
+
+    def call(input)
+      call_chain.inject(input) {|m, e| e.call(m) }
+    end
+
+    protected
+
+    def chain_modified!
+      @call_chain = nil
+    end
+
+    def call_chain
+      @call_chain ||= @chain.map do |name, constructor|
+        f = constructor.call(self)
+        raise "Constructor #{name} must return callable object" if f && !f.respond_to?(:call)
+        f
+      end.compact
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/erb/engine.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Temple
+  module ERB
+    # Example ERB engine implementation
+    #
+    # @api public
+    class Engine < Temple::Engine
+      use Temple::ERB::Parser
+      use Temple::ERB::Trimming
+      filter :Escapable
+      filter :StringSplitter
+      filter :StaticAnalyzer
+      filter :MultiFlattener
+      filter :StaticMerger
+      generator :ArrayBuffer
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/temple-0.10.4/lib/temple/erb/parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module Temple
+  module ERB
+    # Example ERB parser
+    #
+    # @api public
+    class Parser < Temple::Parser
+      ERB_PATTERN = /(\n|<%%|%%>)|<%(==?|\#)?(.*?)?-?%>/m
+
+      def call(input)
+        result = [:multi]
+        pos = 0
+        input.scan(ERB_PATTERN) do |token, indicator, code|
+          text = input[pos...$~.begin(0)]
+          pos  = $~.end(0)
+          if token
+            case token
+            when "\n"
+              result << [:static, "#{text}\n"] << [:newline]
+            when '<%%', '%%>'
+              result << [:static, text] unless text.empty?
+              token.slice!(1)
+              result << [:static, token]
+            end
+          else
+            result << [:static, text] unless text.empty?
+            case indicator
+            when '#'
+              result << [:code, "\n" * code.count("\n")]
+            when /=/
+              result << [:escape, indicator.size == 2, [:dynamic, code]]
+            else
+              result << [:code, code]
+            end
+          end
+        end
+        result << [:static, input[pos..-1]]
+      end
+    end
+  end
+end