brakeman 4.3.1 → 5.0.0

data/bundle/ruby/2.5.0/gems/tilt-2.0.8/docs/common.css

@@ -1,14 +0,0 @@
-body {
-  line-height: 1.5;
-  font-size: 14px;
-}
-
-.frames #content {
-  margin: 0;
-}
-
-#content {
-  margin: 0 auto;
-  max-width: 720px;
-}
-

data/bundle/ruby/2.5.0/gems/tilt-2.0.8/lib/tilt.rb

@@ -1,166 +0,0 @@
-require 'tilt/mapping'
-require 'tilt/template'
-
-# Namespace for Tilt. This module is not intended to be included anywhere.
-module Tilt
-  # Current version.
-  VERSION = '2.0.8'
-
-  @default_mapping = Mapping.new
-
-  # @return [Tilt::Mapping] the main mapping object
-  def self.default_mapping
-    @default_mapping
-  end
-
-  # @private
-  def self.lazy_map
-    default_mapping.lazy_map
-  end
-
-  # @see Tilt::Mapping#register
-  def self.register(template_class, *extensions)
-    default_mapping.register(template_class, *extensions)
-  end
-
-  # @see Tilt::Mapping#register_lazy
-  def self.register_lazy(class_name, file, *extensions)
-    default_mapping.register_lazy(class_name, file, *extensions)
-  end
-
-  # @deprecated Use {register} instead.
-  def self.prefer(template_class, *extensions)
-    register(template_class, *extensions)
-  end
-
-  # @see Tilt::Mapping#registered?
-  def self.registered?(ext)
-    default_mapping.registered?(ext)
-  end
-
-  # @see Tilt::Mapping#new
-  def self.new(file, line=nil, options={}, &block)
-    default_mapping.new(file, line, options, &block)
-  end
-
-  # @see Tilt::Mapping#[]
-  def self.[](file)
-    default_mapping[file]
-  end
-
-  # @see Tilt::Mapping#template_for
-  def self.template_for(file)
-    default_mapping.template_for(file)
-  end
-
-  # @see Tilt::Mapping#templates_for
-  def self.templates_for(file)
-    default_mapping.templates_for(file)
-  end
-
-  # @return the template object that is currently rendering.
-  #
-  # @example
-  #   tmpl = Tilt['index.erb'].new { '<%= Tilt.current_template %>' }
-  #   tmpl.render == tmpl.to_s
-  #
-  # @note This is currently an experimental feature and might return nil
-  #   in the future.
-  def self.current_template
-    Thread.current[:tilt_current_template]
-  end
-
-  # Extremely simple template cache implementation. Calling applications
-  # create a Tilt::Cache instance and use #fetch with any set of hashable
-  # arguments (such as those to Tilt.new):
-  #
-  #     cache = Tilt::Cache.new
-  #     cache.fetch(path, line, options) { Tilt.new(path, line, options) }
-  #
-  # Subsequent invocations return the already loaded template object.
-  #
-  # @note
-  #   Tilt::Cache is a thin wrapper around Hash.  It has the following
-  #   limitations:
-  #   * Not thread-safe.
-  #   * Size is unbounded.
-  #   * Keys are not copied defensively, and should not be modified after
-  #     being passed to #fetch.  More specifically, the values returned by
-  #     key#hash and key#eql? should not change.
-  #   If this is too limiting for you, use a different cache implementation.
-  class Cache
-    def initialize
-      @cache = {}
-    end
-
-    # Caches a value for key, or returns the previously cached value.
-    # If a value has been previously cached for key then it is
-    # returned. Otherwise, block is yielded to and its return value
-    # which may be nil, is cached under key and returned.
-    # @yield
-    # @yieldreturn the value to cache for key
-    def fetch(*key)
-      @cache.fetch(key) do
-        @cache[key] = yield
-      end
-    end
-
-    # Clears the cache.
-    def clear
-      @cache = {}
-    end
-  end
-
-
-  # Template Implementations ================================================
-
-  # ERB
-  register_lazy :ERBTemplate,    'tilt/erb',    'erb', 'rhtml'
-  register_lazy :ErubisTemplate, 'tilt/erubis', 'erb', 'rhtml', 'erubis'
-  register_lazy :ErubiTemplate,  'tilt/erubi',  'erb', 'rhtml', 'erubi'
-
-  # Markdown
-  register_lazy :BlueClothTemplate,    'tilt/bluecloth',    'markdown', 'mkd', 'md'
-  register_lazy :MarukuTemplate,       'tilt/maruku',       'markdown', 'mkd', 'md'
-  register_lazy :KramdownTemplate,     'tilt/kramdown',     'markdown', 'mkd', 'md'
-  register_lazy :RDiscountTemplate,    'tilt/rdiscount',    'markdown', 'mkd', 'md'
-  register_lazy :RedcarpetTemplate,    'tilt/redcarpet',    'markdown', 'mkd', 'md'
-  register_lazy :CommonMarkerTemplate, 'tilt/commonmarker', 'markdown', 'mkd', 'md'
-  register_lazy :PandocTemplate,       'tilt/pandoc',       'markdown', 'mkd', 'md'
-
-  # Rest (sorted by name)
-  register_lazy :AsciidoctorTemplate,  'tilt/asciidoc',  'ad', 'adoc', 'asciidoc'
-  register_lazy :BabelTemplate,        'tilt/babel',     'es6', 'babel', 'jsx'
-  register_lazy :BuilderTemplate,      'tilt/builder',   'builder'
-  register_lazy :CSVTemplate,          'tilt/csv',       'rcsv'
-  register_lazy :CoffeeScriptTemplate, 'tilt/coffee',    'coffee'
-  register_lazy :CoffeeScriptLiterateTemplate, 'tilt/coffee', 'litcoffee'
-  register_lazy :CreoleTemplate,       'tilt/creole',    'wiki', 'creole'
-  register_lazy :EtanniTemplate,       'tilt/etanni',    'etn', 'etanni'
-  register_lazy :HamlTemplate,         'tilt/haml',      'haml'
-  register_lazy :LessTemplate,         'tilt/less',      'less'
-  register_lazy :LiquidTemplate,       'tilt/liquid',    'liquid'
-  register_lazy :LiveScriptTemplate,   'tilt/livescript','ls'
-  register_lazy :MarkabyTemplate,      'tilt/markaby',   'mab'
-  register_lazy :NokogiriTemplate,     'tilt/nokogiri',  'nokogiri'
-  register_lazy :PlainTemplate,        'tilt/plain',     'html'
-  register_lazy :PrawnTemplate,        'tilt/prawn',     'prawn'
-  register_lazy :RDocTemplate,         'tilt/rdoc',      'rdoc'
-  register_lazy :RadiusTemplate,       'tilt/radius',    'radius'
-  register_lazy :RedClothTemplate,     'tilt/redcloth',  'textile'
-  register_lazy :RstPandocTemplate,    'tilt/rst-pandoc', 'rst'
-  register_lazy :SassTemplate,         'tilt/sass',      'sass'
-  register_lazy :ScssTemplate,         'tilt/sass',      'scss'
-  register_lazy :SigilTemplate,        'tilt/sigil',     'sigil'
-  register_lazy :StringTemplate,       'tilt/string',    'str'
-  register_lazy :TypeScriptTemplate,   'tilt/typescript', 'ts', 'tsx'
-  register_lazy :WikiClothTemplate,    'tilt/wikicloth', 'wiki', 'mediawiki', 'mw'
-  register_lazy :YajlTemplate,         'tilt/yajl',      'yajl'
-
-  # External template engines
-  register_lazy 'Slim::Template',            'slim',            'slim'
-  register_lazy 'Tilt::HandlebarsTemplate',  'tilt/handlebars', 'handlebars', 'hbs'
-  register_lazy 'Tilt::OrgTemplate',         'org-ruby',        'org'
-  register_lazy 'Opal::Processor',           'opal',            'opal', 'rb'
-  register_lazy 'Tilt::JbuilderTemplate',    'tilt/jbuilder',   'jbuilder'
-end

data/bundle/ruby/2.5.0/gems/tilt-2.0.8/lib/tilt/commonmarker.rb

@@ -1,21 +0,0 @@
-require 'tilt/template'
-require 'commonmarker'
-
-module Tilt
-  class CommonMarkerTemplate < Template
-    self.default_mime_type = 'text/html'
-
-    def prepare
-      @engine = nil
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      CommonMarker.render_html(data, :DEFAULT)
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/tilt-2.0.8/lib/tilt/erb.rb

@@ -1,57 +0,0 @@
-require 'tilt/template'
-require 'erb'
-
-module Tilt
-  # ERB template implementation. See:
-  # http://www.ruby-doc.org/stdlib/libdoc/erb/rdoc/classes/ERB.html
-  class ERBTemplate < Template
-    @@default_output_variable = '_erbout'
-
-    def self.default_output_variable
-      @@default_output_variable
-    end
-
-    def self.default_output_variable=(name)
-      warn "#{self}.default_output_variable= has been replaced with the :outvar-option"
-      @@default_output_variable = name
-    end
-
-    def prepare
-      @outvar = options[:outvar] || self.class.default_output_variable
-      options[:trim] = '<>' if !(options[:trim] == false) && (options[:trim].nil? || options[:trim] == true)
-      @engine = ::ERB.new(data, options[:safe], options[:trim], @outvar)
-    end
-
-    def precompiled_template(locals)
-      source = @engine.src
-      source
-    end
-
-    def precompiled_preamble(locals)
-      <<-RUBY
-        begin
-          __original_outvar = #{@outvar} if defined?(#{@outvar})
-          #{super}
-      RUBY
-    end
-
-    def precompiled_postamble(locals)
-      <<-RUBY
-          #{super}
-        ensure
-          #{@outvar} = __original_outvar
-        end
-      RUBY
-    end
-
-    # ERB generates a line to specify the character coding of the generated
-    # source in 1.9. Account for this in the line offset.
-    if RUBY_VERSION >= '1.9.0'
-      def precompiled(locals)
-        source, offset = super
-        [source, offset + 1]
-      end
-    end
-  end
-end
-

data/bundle/ruby/2.5.0/gems/tilt-2.0.8/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/2.5.0/gems/tilt-2.0.8/lib/tilt/sass.rb

@@ -1,41 +0,0 @@
-require 'tilt/template'
-require 'sass'
-
-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'
-
-    def prepare
-      @engine = ::Sass::Engine.new(data, sass_options)
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.render
-    end
-
-    def allows_script?
-      false
-    end
-
-  private
-    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_options
-      options.merge(:filename => eval_file, :line => line, :syntax => :scss)
-    end
-  end
-
-end
-

data/bundle/ruby/2.5.0/gems/tilt-2.0.8/lib/tilt/template.rb

@@ -1,302 +0,0 @@
-require 'thread'
-
-module Tilt
-  # @private
-  TOPOBJECT = if RUBY_VERSION >= '2.0'
-    # @private
-    module CompiledTemplates
-      self
-    end
-  elsif RUBY_VERSION >= '1.9'
-    BasicObject
-  else
-    Object
-  end
-  # @private
-  LOCK = Mutex.new
-
-  # Base class for template implementations. Subclasses must implement
-  # the #prepare method and one of the #evaluate or #precompiled_template
-  # methods.
-  class Template
-    # Template source; loaded from a file or given directly.
-    attr_reader :data
-
-    # The name of the file where the template data was loaded from.
-    attr_reader :file
-
-    # The line number in #file where template data was loaded from.
-    attr_reader :line
-
-    # A Hash of template engine specific options. This is passed directly
-    # to the underlying engine and is not used by the generic template
-    # interface.
-    attr_reader :options
-
-    class << self
-      # An empty Hash that the template engine can populate with various
-      # metadata.
-      def metadata
-        @metadata ||= {}
-      end
-
-      # @deprecated Use `.metadata[:mime_type]` instead.
-      def default_mime_type
-        metadata[:mime_type]
-      end
-
-      # @deprecated Use `.metadata[:mime_type] = val` instead.
-      def default_mime_type=(value)
-        metadata[:mime_type] = value
-      end
-    end
-
-    # Create a new template with the file, line, and options specified. By
-    # default, template data is read from the file. When a block is given,
-    # it should read template data and return as a String. When file is nil,
-    # a block is required.
-    #
-    # All arguments are optional.
-    def initialize(file=nil, line=1, options={}, &block)
-      @file, @line, @options = nil, 1, {}
-
-      [options, line, file].compact.each do |arg|
-        case
-        when arg.respond_to?(:to_str)  ; @file = arg.to_str
-        when arg.respond_to?(:to_int)  ; @line = arg.to_int
-        when arg.respond_to?(:to_hash) ; @options = arg.to_hash.dup
-        when arg.respond_to?(:path)    ; @file = arg.path
-        when arg.respond_to?(:to_path) ; @file = arg.to_path
-        else raise TypeError, "Can't load the template file. Pass a string with a path " +
-          "or an object that responds to 'to_str', 'path' or 'to_path'"
-        end
-      end
-
-      raise ArgumentError, "file or block required" if (@file || block).nil?
-
-      # used to hold compiled template methods
-      @compiled_method = {}
-
-      # used on 1.9 to set the encoding if it is not set elsewhere (like a magic comment)
-      # currently only used if template compiles to ruby
-      @default_encoding = @options.delete :default_encoding
-
-      # load template data and prepare (uses binread to avoid encoding issues)
-      @reader = block || lambda { |t| read_template_file }
-      @data = @reader.call(self)
-
-      if @data.respond_to?(:force_encoding)
-        if default_encoding
-          @data = @data.dup if @data.frozen?
-          @data.force_encoding(default_encoding)
-        end
-
-        if !@data.valid_encoding?
-          raise Encoding::InvalidByteSequenceError, "#{eval_file} is not valid #{@data.encoding}"
-        end
-      end
-
-      prepare
-    end
-
-    # Render the template in the given scope with the locals specified. If a
-    # block is given, it is typically available within the template via
-    # +yield+.
-    def render(scope=nil, locals={}, &block)
-      scope ||= Object.new
-      current_template = Thread.current[:tilt_current_template]
-      Thread.current[:tilt_current_template] = self
-      evaluate(scope, locals || {}, &block)
-    ensure
-      Thread.current[:tilt_current_template] = current_template
-    end
-
-    # The basename of the template file.
-    def basename(suffix='')
-      File.basename(file, suffix) if file
-    end
-
-    # The template file's basename with all extensions chomped off.
-    def name
-      basename.split('.', 2).first if basename
-    end
-
-    # The filename used in backtraces to describe the template.
-    def eval_file
-      file || '(__TEMPLATE__)'
-    end
-
-    # An empty Hash that the template engine can populate with various
-    # metadata.
-    def metadata
-      if respond_to?(:allows_script?)
-        self.class.metadata.merge(:allows_script => allows_script?)
-      else
-        self.class.metadata
-      end
-    end
-
-    protected
-
-    # @!group For template implementations
-
-    # The encoding of the source data. Defaults to the
-    # default_encoding-option if present. You may override this method
-    # in your template class if you have a better hint of the data's
-    # encoding.
-    def default_encoding
-      @default_encoding
-    end
-
-    # Do whatever preparation is necessary to setup the underlying template
-    # engine. Called immediately after template data is loaded. Instance
-    # variables set in this method are available when #evaluate is called.
-    #
-    # Subclasses must provide an implementation of this method.
-    def prepare
-      raise NotImplementedError
-    end
-
-    # Execute the compiled template and return the result string. Template
-    # evaluation is guaranteed to be performed in the scope object with the
-    # locals specified and with support for yielding to the block.
-    #
-    # This method is only used by source generating templates. Subclasses that
-    # override render() may not support all features.
-    def evaluate(scope, locals, &block)
-      locals_keys = locals.keys
-      locals_keys.sort!{|x, y| x.to_s <=> y.to_s}
-      method = compiled_method(locals_keys)
-      method.bind(scope).call(locals, &block)
-    end
-
-    # Generates all template source by combining the preamble, template, and
-    # postamble and returns a two-tuple of the form: [source, offset], where
-    # source is the string containing (Ruby) source code for the template and
-    # offset is the integer line offset where line reporting should begin.
-    #
-    # Template subclasses may override this method when they need complete
-    # control over source generation or want to adjust the default line
-    # offset. In most cases, overriding the #precompiled_template method is
-    # easier and more appropriate.
-    def precompiled(local_keys)
-      preamble = precompiled_preamble(local_keys)
-      template = precompiled_template(local_keys)
-      postamble = precompiled_postamble(local_keys)
-      source = String.new
-
-      # Ensure that our generated source code has the same encoding as the
-      # the source code generated by the template engine.
-      if source.respond_to?(:force_encoding)
-        template_encoding = extract_encoding(template)
-
-        source.force_encoding(template_encoding)
-        template.force_encoding(template_encoding)
-      end
-
-      source << preamble << "\n" << template << "\n" << postamble
-
-      [source, preamble.count("\n")+1]
-    end
-
-    # A string containing the (Ruby) source code for the template. The
-    # default Template#evaluate implementation requires either this
-    # method or the #precompiled method be overridden. When defined,
-    # the base Template guarantees correct file/line handling, locals
-    # support, custom scopes, proper encoding, and support for template
-    # compilation.
-    def precompiled_template(local_keys)
-      raise NotImplementedError
-    end
-
-    def precompiled_preamble(local_keys)
-      ''
-    end
-
-    def precompiled_postamble(local_keys)
-      ''
-    end
-
-    # !@endgroup
-
-    private
-
-    def read_template_file
-      data = File.open(file, 'rb') { |io| io.read }
-      if data.respond_to?(:force_encoding)
-        # Set it to the default external (without verifying)
-        data.force_encoding(Encoding.default_external) if Encoding.default_external
-      end
-      data
-    end
-
-    # The compiled method for the locals keys provided.
-    def compiled_method(locals_keys)
-      LOCK.synchronize do
-        @compiled_method[locals_keys] ||= compile_template_method(locals_keys)
-      end
-    end
-
-    def local_extraction(local_keys)
-      local_keys.map do |k|
-        if k.to_s =~ /\A[a-z_][a-zA-Z_0-9]*\z/
-          "#{k} = locals[#{k.inspect}]"
-        else
-          raise "invalid locals key: #{k.inspect} (keys must be variable names)"
-        end
-      end.join("\n")
-    end
-
-    def compile_template_method(local_keys)
-      source, offset = precompiled(local_keys)
-      local_code = local_extraction(local_keys)
-
-      method_name = "__tilt_#{Thread.current.object_id.abs}"
-      method_source = String.new
-
-      if method_source.respond_to?(:force_encoding)
-        method_source.force_encoding(source.encoding)
-      end
-
-      method_source << <<-RUBY
-        TOPOBJECT.class_eval do
-          def #{method_name}(locals)
-            Thread.current[:tilt_vars] = [self, locals]
-            class << self
-              this, locals = Thread.current[:tilt_vars]
-              locals = locals
-              this.instance_eval do
-                #{local_code}
-      RUBY
-      offset += method_source.count("\n")
-      method_source << source
-      method_source << "\nend;end;end;end"
-      Object.class_eval(method_source, eval_file, line - offset)
-      unbind_compiled_method(method_name)
-    end
-
-    def unbind_compiled_method(method_name)
-      method = TOPOBJECT.instance_method(method_name)
-      TOPOBJECT.class_eval { remove_method(method_name) }
-      method
-    end
-
-    def extract_encoding(script)
-      extract_magic_comment(script) || script.encoding
-    end
-
-    def extract_magic_comment(script)
-      binary(script) do
-        script[/\A[ \t]*\#.*coding\s*[=:]\s*([[:alnum:]\-_]+).*$/n, 1]
-      end
-    end
-
-    def binary(string)
-      original_encoding = string.encoding
-      string.force_encoding(Encoding::BINARY)
-      yield
-    ensure
-      string.force_encoding(original_encoding)
-    end
-  end
-end