brakeman 5.2.2 → 7.1.1

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

@@ -1,170 +0,0 @@
-module Temple
-  module Mixins
-    # @api private
-    module GrammarDSL
-      class Rule
-        def initialize(grammar)
-          @grammar = grammar
-        end
-
-        def match?(exp)
-          match(exp, [])
-        end
-        alias === match?
-        alias =~ match?
-
-        def |(rule)
-          Or.new(@grammar, self, rule)
-        end
-
-        def copy_to(grammar)
-          copy = dup.instance_eval { @grammar = grammar; self }
-          copy.after_copy(self) if copy.respond_to?(:after_copy)
-          copy
-        end
-      end
-
-      class Or < Rule
-        def initialize(grammar, *children)
-          super(grammar)
-          @children = children.map {|rule| @grammar.Rule(rule) }
-        end
-
-        def <<(rule)
-          @children << @grammar.Rule(rule)
-          self
-        end
-
-        alias | <<
-
-        def match(exp, unmatched)
-          tmp = []
-          @children.any? {|rule| rule.match(exp, tmp) } || (unmatched.concat(tmp) && false)
-        end
-
-        def after_copy(source)
-          @children = @children.map {|child| child.copy_to(@grammar) }
-        end
-      end
-
-      class Root < Or
-        def initialize(grammar, name)
-          super(grammar)
-          @name = name.to_sym
-        end
-
-        def match(exp, unmatched)
-          success = super
-          unmatched << [@name, exp] unless success
-          success
-        end
-
-        def validate!(exp)
-          unmatched = []
-          unless match(exp, unmatched)
-            require 'pp'
-            entry = unmatched.first
-            unmatched.reverse_each do |u|
-              entry = u if u.flatten.size < entry.flatten.size
-            end
-            raise(InvalidExpression, PP.pp(entry.last, "#{@grammar}::#{entry.first} did not match\n"))
-          end
-        end
-
-        def copy_to(grammar)
-          grammar.const_defined?(@name) ? grammar.const_get(@name) : super
-        end
-
-        def after_copy(source)
-          @grammar.const_set(@name, self)
-          super
-        end
-      end
-
-      class Element < Or
-        def initialize(grammar, rule)
-          super(grammar)
-          @rule = grammar.Rule(rule)
-        end
-
-        def match(exp, unmatched)
-          return false unless Array === exp && !exp.empty?
-          head, *tail = exp
-          @rule.match(head, unmatched) && super(tail, unmatched)
-        end
-
-        def after_copy(source)
-          @children = @children.map do |child|
-            child == source ? self : child.copy_to(@grammar)
-          end
-          @rule = @rule.copy_to(@grammar)
-        end
-      end
-
-      class Value < Rule
-        def initialize(grammar, value)
-          super(grammar)
-          @value = value
-        end
-
-        def match(exp, unmatched)
-          @value === exp
-        end
-      end
-
-      def extended(mod)
-        mod.extend GrammarDSL
-        constants.each do |name|
-          const_get(name).copy_to(mod) if Rule === const_get(name)
-        end
-      end
-
-      def match?(exp)
-        const_get(:Expression).match?(exp)
-      end
-      alias === match?
-      alias =~ match?
-
-      def validate!(exp)
-        const_get(:Expression).validate!(exp)
-      end
-
-      def Value(value)
-        Value.new(self, value)
-      end
-
-      def Rule(rule)
-        case rule
-        when Rule
-          rule
-        when Symbol, Class, true, false, nil
-          Value(rule)
-        when Array
-          start = Or.new(self)
-          curr = [start]
-          rule.each do |elem|
-            if elem =~ /^(.*)(\*|\?|\+)$/
-              elem = Element.new(self, const_get($1))
-              curr.each {|c| c << elem }
-              elem << elem if $2 != '?'
-              curr = $2 == '+' ? [elem] : (curr << elem)
-            else
-              elem = Element.new(self, elem)
-              curr.each {|c| c << elem }
-              curr = [elem]
-            end
-          end
-          elem = Value([])
-          curr.each {|c| c << elem }
-          start
-        else
-          raise ArgumentError, "Invalid grammar rule '#{rule.inspect}'"
-        end
-      end
-
-      def const_missing(name)
-        const_set(name, Root.new(self, name))
-      end
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-module Temple
-  module Mixins
-    # @api public
-    module ClassOptions
-      def set_default_options(opts)
-        warn 'set_default_options has been deprecated, use set_options'
-        set_options(opts)
-      end
-
-      def default_options
-        warn 'default_options has been deprecated, use options'
-        options
-      end
-
-      def set_options(opts)
-        options.update(opts)
-      end
-
-      def options
-        @options ||= OptionMap.new(superclass.respond_to?(:options) ?
-                                   superclass.options : nil) do |hash, key, what|
-          warn "#{self}: Option #{key.inspect} is #{what}" unless @option_validator_disabled
-        end
-      end
-
-      def define_options(*opts)
-        if opts.last.respond_to?(:to_hash)
-          hash = opts.pop.to_hash
-          options.add_valid_keys(hash.keys)
-          options.update(hash)
-        end
-        options.add_valid_keys(opts)
-      end
-
-      def define_deprecated_options(*opts)
-        if opts.last.respond_to?(:to_hash)
-          hash = opts.pop.to_hash
-          options.add_deprecated_keys(hash.keys)
-          options.update(hash)
-        end
-        options.add_deprecated_keys(opts)
-      end
-
-      def disable_option_validator!
-        @option_validator_disabled = true
-      end
-    end
-
-    module ThreadOptions
-      def with_options(options)
-        old_options = thread_options
-        Thread.current[thread_options_key] = ImmutableMap.new(options, thread_options)
-        yield
-      ensure
-        Thread.current[thread_options_key] = old_options
-      end
-
-      def thread_options
-        Thread.current[thread_options_key]
-      end
-
-      protected
-
-      def thread_options_key
-        @thread_options_key ||= "#{self.name}-thread-options".to_sym
-      end
-    end
-
-    # @api public
-    module Options
-      def self.included(base)
-        base.class_eval do
-          extend ClassOptions
-          extend ThreadOptions
-        end
-      end
-
-      attr_reader :options
-
-      def initialize(opts = {})
-        self.class.options.validate_map!(opts)
-        self.class.options.validate_map!(self.class.thread_options) if self.class.thread_options
-        @options = ImmutableMap.new({}.update(self.class.options).update(self.class.thread_options || {}).update(opts))
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module Temple
-  module Mixins
-    # @api private
-    module Template
-      include ClassOptions
-
-      def compile(code, options)
-        engine = options.delete(:engine)
-        raise 'No engine configured' unless engine
-        engine.new(options).call(code)
-      end
-
-      def register_as(*names)
-        raise NotImplementedError
-      end
-
-      def create(engine, options)
-        register_as = options.delete(:register_as)
-        template = Class.new(self)
-        template.disable_option_validator!
-        template.options[:engine] = engine
-        template.options.update(options)
-        template.register_as(*register_as) if register_as
-        template
-      end
-    end
-  end
-end

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

@@ -1,8 +0,0 @@
-module Temple
-  # Temple base parser
-  # @api public
-  class Parser
-    include Utils
-    include Mixins::Options
-  end
-end

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

@@ -1,77 +0,0 @@
-begin
-  require 'ripper'
-rescue LoadError
-end
-
-module Temple
-  module StaticAnalyzer
-    STATIC_TOKENS = [
-      :on_tstring_beg, :on_tstring_end, :on_tstring_content,
-      :on_embexpr_beg, :on_embexpr_end,
-      :on_lbracket, :on_rbracket,
-      :on_qwords_beg, :on_words_sep, :on_qwords_sep,
-      :on_lparen, :on_rparen,
-      :on_lbrace, :on_rbrace, :on_label,
-      :on_int, :on_float, :on_imaginary,
-      :on_comma, :on_sp, :on_ignored_nl,
-    ].freeze
-
-    DYNAMIC_TOKENS = [
-      :on_ident, :on_period,
-    ].freeze
-
-    STATIC_KEYWORDS = [
-      'true', 'false', 'nil',
-    ].freeze
-
-    STATIC_OPERATORS = [
-      '=>',
-    ].freeze
-
-    class << self
-      def available?
-        defined?(Ripper) && Ripper.respond_to?(:lex)
-      end
-
-      def static?(code)
-        return false if code.nil? || code.strip.empty?
-        return false if syntax_error?(code)
-
-        Ripper.lex(code).each do |_, token, str|
-          case token
-          when *STATIC_TOKENS
-            # noop
-          when :on_kw
-            return false unless STATIC_KEYWORDS.include?(str)
-          when :on_op
-            return false unless STATIC_OPERATORS.include?(str)
-          when *DYNAMIC_TOKENS
-            return false
-          else
-            return false
-          end
-        end
-        true
-      end
-
-      def syntax_error?(code)
-        SyntaxChecker.new(code).parse
-        false
-      rescue SyntaxChecker::ParseError
-        true
-      end
-    end
-
-    if defined?(Ripper)
-      class SyntaxChecker < Ripper
-        class ParseError < StandardError; end
-
-        private
-
-        def on_parse_error(*)
-          raise ParseError
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module Temple
-  module Templates
-    class Rails
-      extend Mixins::Template
-
-      def call(template, source = nil)
-        opts = {}.update(self.class.options).update(file: template.identifier)
-        self.class.compile((source || template.source), opts)
-      end
-
-      def supports_streaming?
-        self.class.options[:streaming]
-      end
-
-      def self.register_as(*names)
-        raise 'Rails is not loaded - Temple::Templates::Rails cannot be used' unless defined?(::ActionView)
-        if ::ActiveSupport::VERSION::MAJOR < 3 || ::ActiveSupport::VERSION::MAJOR == 3 && ::ActiveSupport::VERSION::MINOR < 1
-          raise "Temple supports only Rails 3.1 and greater, your Rails version is #{::ActiveSupport::VERSION::STRING}"
-        end
-        names.each do |name|
-          ::ActionView::Template.register_template_handler name.to_sym, new
-        end
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-require 'tilt'
-
-module Temple
-  module Templates
-    class Tilt < ::Tilt::Template
-      extend Mixins::Template
-
-      define_options mime_type: 'text/html'
-
-      def self.default_mime_type
-        options[:mime_type]
-      end
-
-      def self.default_mime_type=(mime_type)
-        options[:mime_type] = mime_type
-      end
-
-      # Prepare Temple template
-      #
-      # Called immediately after template data is loaded.
-      #
-      # @return [void]
-      def prepare
-        opts = {}.update(self.class.options).update(options).update(file: eval_file)
-        opts.delete(:mime_type)
-        if opts.include?(:outvar)
-          opts[:buffer] = opts.delete(:outvar)
-          opts[:save_buffer] = true
-        end
-        @src = self.class.compile(data, opts)
-      end
-
-      # A string containing the (Ruby) source code for the template.
-      #
-      # @param [Hash]   locals Local variables
-      # @return [String] Compiled template ruby code
-      def precompiled_template(locals = {})
-        @src
-      end
-
-      def self.register_as(*names)
-        ::Tilt.register(self, *names.map(&:to_s))
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-module Temple
-  # @api public
-  module Templates
-    autoload :Tilt,  'temple/templates/tilt'
-    autoload :Rails, 'temple/templates/rails'
-
-    def self.method_missing(name, engine, options = {})
-      const_get(name).create(engine, options)
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-begin
-  require 'escape_utils'
-rescue LoadError
-  begin
-    require 'cgi/escape'
-  rescue LoadError
-  end
-end
-
-module Temple
-  # @api public
-  module Utils
-    extend self
-
-    # Returns an escaped copy of `html`.
-    # Strings which are declared as html_safe are not escaped.
-    #
-    # @param html [String] The string to escape
-    # @return [String] The escaped string
-    def escape_html_safe(html)
-      html.html_safe? ? html : escape_html(html)
-    end
-
-    if defined?(EscapeUtils)
-      # Returns an escaped copy of `html`.
-      #
-      # @param html [String] The string to escape
-      # @return [String] The escaped string
-      def escape_html(html)
-        EscapeUtils.escape_html(html.to_s, false)
-      end
-    elsif defined?(CGI.escapeHTML)
-      # Returns an escaped copy of `html`.
-      #
-      # @param html [String] The string to escape
-      # @return [String] The escaped string
-      def escape_html(html)
-        CGI.escapeHTML(html.to_s)
-      end
-    else
-      # Used by escape_html
-      # @api private
-      ESCAPE_HTML = {
-        '&'  => '&',
-        '"'  => '"',
-        '\'' => ''',
-        '<'  => '&lt;',
-        '>'  => '&gt;'
-      }.freeze
-
-      ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
-
-      # Returns an escaped copy of `html`.
-      #
-      # @param html [String] The string to escape
-      # @return [String] The escaped string
-      def escape_html(html)
-        html.to_s.gsub(ESCAPE_HTML_PATTERN, ESCAPE_HTML)
-      end
-    end
-
-    # Generate unique variable name
-    #
-    # @param prefix [String] Variable name prefix
-    # @return [String] Variable name
-    def unique_name(prefix = nil)
-      @unique_name ||= 0
-      prefix ||= (@unique_prefix ||= self.class.name.gsub('::'.freeze, '_'.freeze).downcase)
-      "_#{prefix}#{@unique_name += 1}"
-    end
-
-    # Check if expression is empty
-    #
-    # @param exp [Array] Temple expression
-    # @return true if expression is empty
-    def empty_exp?(exp)
-      case exp[0]
-      when :multi
-        exp[1..-1].all? {|e| empty_exp?(e) }
-      when :newline
-        true
-      else
-        false
-      end
-    end
-
-    def indent_dynamic(text, indent_next, indent, pre_tags = nil)
-      text = text.to_s
-      safe = text.respond_to?(:html_safe?) && text.html_safe?
-      return text if pre_tags && text =~ pre_tags
-
-      level = text.scan(/^\s*/).map(&:size).min
-      text = text.gsub(/(?!\A)^\s{#{level}}/, '') if level > 0
-
-      text = text.sub(/\A\s*\n?/, "\n".freeze) if indent_next
-      text = text.gsub("\n".freeze, indent)
-
-      safe ? text.html_safe : text
-    end
-  end
-end

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

@@ -1,3 +0,0 @@
-module Temple
-  VERSION = '0.8.2'
-end

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

@@ -1,67 +0,0 @@
-require 'temple/version'
-
-module Temple
-  autoload :InvalidExpression,    'temple/exceptions'
-  autoload :FilterError,          'temple/exceptions'
-  autoload :Generator,            'temple/generator'
-  autoload :Parser,               'temple/parser'
-  autoload :Engine,               'temple/engine'
-  autoload :Utils,                'temple/utils'
-  autoload :Filter,               'temple/filter'
-  autoload :Templates,            'temple/templates'
-  autoload :Grammar,              'temple/grammar'
-  autoload :ImmutableMap,         'temple/map'
-  autoload :MutableMap,           'temple/map'
-  autoload :OptionMap,            'temple/map'
-  autoload :StaticAnalyzer,       'temple/static_analyzer'
-
-  module Mixins
-    autoload :Dispatcher,         'temple/mixins/dispatcher'
-    autoload :CompiledDispatcher, 'temple/mixins/dispatcher'
-    autoload :EngineDSL,          'temple/mixins/engine_dsl'
-    autoload :GrammarDSL,         'temple/mixins/grammar_dsl'
-    autoload :Options,            'temple/mixins/options'
-    autoload :ClassOptions,       'temple/mixins/options'
-    autoload :Template,           'temple/mixins/template'
-  end
-
-  module ERB
-    autoload :Engine,             'temple/erb/engine'
-    autoload :Parser,             'temple/erb/parser'
-    autoload :Trimming,           'temple/erb/trimming'
-    autoload :Template,           'temple/erb/template'
-  end
-
-  module Generators
-    autoload :ERB,                'temple/generators/erb'
-    autoload :Array,              'temple/generators/array'
-    autoload :ArrayBuffer,        'temple/generators/array_buffer'
-    autoload :StringBuffer,       'temple/generators/string_buffer'
-    autoload :RailsOutputBuffer,  'temple/generators/rails_output_buffer'
-  end
-
-  module Filters
-    autoload :CodeMerger,         'temple/filters/code_merger'
-    autoload :ControlFlow,        'temple/filters/control_flow'
-    autoload :MultiFlattener,     'temple/filters/multi_flattener'
-    autoload :StaticAnalyzer,     'temple/filters/static_analyzer'
-    autoload :StaticMerger,       'temple/filters/static_merger'
-    autoload :StringSplitter,     'temple/filters/string_splitter'
-    autoload :DynamicInliner,     'temple/filters/dynamic_inliner'
-    autoload :Escapable,          'temple/filters/escapable'
-    autoload :Eraser,             'temple/filters/eraser'
-    autoload :Validator,          'temple/filters/validator'
-    autoload :Encoding,           'temple/filters/encoding'
-    autoload :RemoveBOM,          'temple/filters/remove_bom'
-  end
-
-  module HTML
-    autoload :Dispatcher,         'temple/html/dispatcher'
-    autoload :Filter,             'temple/html/filter'
-    autoload :Fast,               'temple/html/fast'
-    autoload :Pretty,             'temple/html/pretty'
-    autoload :AttributeMerger,    'temple/html/attribute_merger'
-    autoload :AttributeRemover,   'temple/html/attribute_remover'
-    autoload :AttributeSorter,    'temple/html/attribute_sorter'
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/temple.gemspec

@@ -1,29 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.dirname(__FILE__) + '/lib/temple/version'
-require 'date'
-
-Gem::Specification.new do |s|
-  s.name          = 'temple'
-  s.version       = Temple::VERSION
-  s.date          = Date.today.to_s
-
-  s.authors       = ['Magnus Holm', 'Daniel Mendler']
-  s.email         = ['judofyr@gmail.com', 'mail@daniel-mendler.de']
-  s.homepage      = 'https://github.com/judofyr/temple'
-  s.summary       = 'Template compilation framework in Ruby'
-
-  s.require_paths = %w(lib)
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.license       = 'MIT'
-
-  s.required_ruby_version = '>=1.9.2'
-
-  # Tilt is only development dependency because most parts of Temple
-  # can be used without it.
-  s.add_development_dependency('tilt')
-  s.add_development_dependency('bacon')
-  s.add_development_dependency('rake')
-  s.add_development_dependency('erubis')
-end