brakeman 5.2.2 → 7.1.1

data/bundle/ruby/2.7.0/gems/temple-0.8.2/README.md

@@ -1,267 +0,0 @@
-Temple
-======
-
-[![Build Status](https://secure.travis-ci.org/judofyr/temple.svg?branch=master)](http://travis-ci.org/judofyr/temple) [![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)
-
-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/2.7.0/gems/temple-0.8.2/lib/temple/engine.rb

@@ -1,67 +0,0 @@
-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/2.7.0/gems/temple-0.8.2/lib/temple/erb/engine.rb

@@ -1,15 +0,0 @@
-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 :MultiFlattener
-      filter :StaticMerger
-      generator :ArrayBuffer
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/erb/parser.rb

@@ -1,40 +0,0 @@
-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 <= 1, [:dynamic, code]]
-            else
-              result << [:code, code]
-            end
-          end
-        end
-        result << [:static, input[pos..-1]]
-      end
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/erb/template.rb

@@ -1,11 +0,0 @@
-module Temple
-  # ERB example implementation
-  #
-  # Example usage:
-  #   Temple::ERB::Template.new { "<%= 'Hello, world!' %>" }.render
-  #
-  module ERB
-    # ERB Template class
-    Template = Temple::Templates::Tilt(Engine)
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/erb/trimming.rb

@@ -1,23 +0,0 @@
-module Temple
-  module ERB
-    # ERB trimming like in erubis
-    # Deletes spaces around '<% %>' and leave spaces around '<%= %>'.
-    # @api public
-    class Trimming < Filter
-      define_options trim: true
-
-      def on_multi(*exps)
-        exps = exps.each_with_index.map do |e,i|
-          if e.first == :static && i > 0 && exps[i-1].first == :code
-            [:static, e.last.lstrip]
-          elsif e.first == :static && i < exps.size-1 && exps[i+1].first == :code
-            [:static, e.last.rstrip]
-          else
-            e
-          end
-        end if options[:trim]
-        [:multi, *exps]
-      end
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/exceptions.rb

@@ -1,13 +0,0 @@
-module Temple
-  # Exception raised if invalid temple expression is found
-  #
-  # @api public
-  class InvalidExpression < RuntimeError
-  end
-
-  # Exception raised if something bad happens in a Temple filter
-  #
-  # @api public
-  class FilterError < RuntimeError
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/filter.rb

@@ -1,9 +0,0 @@
-module Temple
-  # Temple base filter
-  # @api public
-  class Filter
-    include Utils
-    include Mixins::Dispatcher
-    include Mixins::Options
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/filters/code_merger.rb

@@ -1,30 +0,0 @@
-module Temple
-  module Filters
-    # @api public
-    class CodeMerger < Filter
-      def on_multi(*exps)
-        result = [:multi]
-        code = nil
-
-        exps.each do |exp|
-          if exp.first == :code
-            if code
-              code << '; ' unless code =~ /\n\Z/
-              code << exp.last
-            else
-              code = exp.last.dup
-              result << [:code, code]
-            end
-          elsif code && exp.first == :newline
-            code << "\n"
-          else
-            result << compile(exp)
-            code = nil
-          end
-        end
-
-        result.size == 2 ? result[1] : result
-      end
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/filters/control_flow.rb

@@ -1,42 +0,0 @@
-module Temple
-  module Filters
-    # Control flow filter which processes [:if, condition, yes-exp, no-exp]
-    # and [:block, code, content] expressions.
-    # This is useful for ruby code generation with lots of conditionals.
-    #
-    # @api public
-    class ControlFlow < Filter
-      def on_if(condition, yes, no = nil)
-        result = [:multi, [:code, "if #{condition}"], compile(yes)]
-        while no && no.first == :if
-          result << [:code, "elsif #{no[1]}"] << compile(no[2])
-          no = no[3]
-        end
-        result << [:code, 'else'] << compile(no) if no
-        result << [:code, 'end']
-        result
-      end
-
-      def on_case(arg, *cases)
-        result = [:multi, [:code, arg ? "case (#{arg})" : 'case']]
-        cases.map do |c|
-          condition, exp = c
-          result << [:code, condition == :else ? 'else' : "when #{condition}"] << compile(exp)
-        end
-        result << [:code, 'end']
-        result
-      end
-
-      def on_cond(*cases)
-        on_case(nil, *cases)
-      end
-
-      def on_block(code, exp)
-        [:multi,
-         [:code, code],
-         compile(exp),
-         [:code, 'end']]
-      end
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/filters/dynamic_inliner.rb

@@ -1,71 +0,0 @@
-module Temple
-  module Filters
-    # Inlines several static/dynamic into a single dynamic.
-    #
-    # @api public
-    class DynamicInliner < Filter
-      def on_multi(*exps)
-        result = [:multi]
-        curr = nil
-        prev = []
-        state = :looking
-
-        exps.each do |exp|
-          type, arg = exp
-
-          case type
-          when :newline
-            if state == :looking
-              # We haven't found any static/dynamic, so let's just add it
-              result << exp
-            else
-              # We've found something, so let's make sure the generated
-              # dynamic contains a newline by escaping a newline and
-              # starting a new string:
-              #
-              # "Hello "\
-              # "#{@world}"
-              prev << exp
-              curr[1] << "\"\\\n\""
-            end
-          when :dynamic, :static
-            case state
-            when :looking
-              # Found a single static/dynamic. We don't want to turn this
-              # into a dynamic yet.  Instead we store it, and if we find
-              # another one, we add both then.
-              state = :single
-              prev = [exp]
-              curr = [:dynamic, '"']
-            when :single
-              # Yes! We found another one. Add the current dynamic to the result.
-              state = :several
-              result << curr
-            end
-            curr[1] << (type == :static ? arg.inspect[1..-2] : "\#{#{arg}}")
-          else
-            if state != :looking
-              # We need to add the closing quote.
-              curr[1] << '"'
-              # If we found a single exp last time, let's add it.
-              result.concat(prev) if state == :single
-            end
-            # Compile the current exp
-            result << compile(exp)
-            # Now we're looking for more!
-            state = :looking
-          end
-        end
-
-        if state != :looking
-          # We need to add the closing quote.
-          curr[1] << '"'
-          # If we found a single exp last time, let's add it.
-          result.concat(prev) if state == :single
-        end
-
-        result.size == 2 ? result[1] : result
-      end
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/filters/encoding.rb

@@ -1,24 +0,0 @@
-module Temple
-  module Filters
-    # Try to encode input string
-    #
-    # @api public
-    class Encoding < Parser
-      define_options encoding: 'utf-8'
-
-      def call(s)
-        if options[:encoding] && s.respond_to?(:encoding)
-          old_enc = s.encoding
-          s = s.dup if s.frozen?
-          s.force_encoding(options[:encoding])
-          # Fall back to old encoding if new encoding is invalid
-          unless s.valid_encoding?
-            s.force_encoding(old_enc)
-            s.force_encoding(::Encoding::BINARY) unless s.valid_encoding?
-          end
-        end
-        s
-      end
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/filters/eraser.rb

@@ -1,22 +0,0 @@
-module Temple
-  module Filters
-    # Erase expressions with a certain type
-    #
-    # @api public
-    class Eraser < Filter
-      # [] is the empty type => keep all
-      define_options :erase, keep: [[]]
-
-      def compile(exp)
-        exp.first == :multi || (do?(:keep, exp) && !do?(:erase, exp)) ?
-          super(exp) : [:multi]
-      end
-
-      protected
-
-      def do?(list, exp)
-        options[list].to_a.map {|type| [*type] }.any? {|type| exp[0,type.size] == type }
-      end
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/filters/escapable.rb

@@ -1,40 +0,0 @@
-module Temple
-  module Filters
-    # Escape dynamic or static expressions.
-    # This filter must be used after Temple::HTML::* and before the generators.
-    # It can be enclosed with Temple::Filters::DynamicInliner filters to
-    # reduce calls to Temple::Utils#escape_html.
-    #
-    # @api public
-    class Escapable < Filter
-      # Activate the usage of html_safe? if it is available (for Rails 3 for example)
-      define_options :escape_code,
-                     :disable_escape,
-                     use_html_safe: ''.respond_to?(:html_safe?)
-
-      def initialize(opts = {})
-        super
-        @escape_code = options[:escape_code] ||
-          "::Temple::Utils.escape_html#{options[:use_html_safe] ? '_safe' : ''}((%s))"
-        @escaper = eval("proc {|v| #{@escape_code % 'v'} }")
-        @escape = false
-      end
-
-      def on_escape(flag, exp)
-        old = @escape
-        @escape = flag && !options[:disable_escape]
-        compile(exp)
-      ensure
-        @escape = old
-      end
-
-      def on_static(value)
-        [:static, @escape ? @escaper[value] : value]
-      end
-
-      def on_dynamic(value)
-        [:dynamic, @escape ? @escape_code % value : value]
-      end
-    end
-  end
-end