RubyGems - brakeman - Versions diffs - 5.2.2 → 7.1.1 - Mend

brakeman 5.2.2 → 7.1.1

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 (952) hide show

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/html/fast.rb DELETED Viewed

@@ -1,130 +0,0 @@
-module Temple
-  module HTML
-    # @api public
-    class Fast < Filter
-      DOCTYPES = {
-        xml: {
-          '1.1'          => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
-          '5'            => '<!DOCTYPE html>',
-          'html'         => '<!DOCTYPE html>',
-          'strict'       => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
-          'frameset'     => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">',
-          'mobile'       => '<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">',
-          'basic'        => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">',
-          'transitional' => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
-          'svg'          => '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">'
-        },
-        html: {
-          '5'            => '<!DOCTYPE html>',
-          'html'         => '<!DOCTYPE html>',
-          'strict'       => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">',
-          'frameset'     => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">',
-          'transitional' => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'
-        }
-      }
-      DOCTYPES[:xhtml] = DOCTYPES[:xml]
-      DOCTYPES.freeze
-      # See http://www.w3.org/html/wg/drafts/html/master/single-page.html#void-elements
-      HTML_VOID_ELEMENTS = %w[area base br col embed hr img input keygen link menuitem meta param source track wbr]
-      define_options format: :xhtml,
-                     attr_quote: '"',
-                     autoclose: HTML_VOID_ELEMENTS,
-                     js_wrapper: nil
-      def initialize(opts = {})
-        super
-        @format = options[:format]
-        unless [:xhtml, :html, :xml].include?(@format)
-          if @format == :html4 || @format == :html5
-            warn "Format #{@format.inspect} is deprecated, use :html"
-            @format = :html
-          else
-            raise ArgumentError, "Invalid format #{@format.inspect}"
-          end
-        end
-        wrapper = options[:js_wrapper]
-        wrapper = @format == :xml || @format == :xhtml ? :cdata : :comment if wrapper == :guess
-        @js_wrapper =
-          case wrapper
-          when :comment
-            [ "<!--\n", "\n//-->" ]
-          when :cdata
-            [ "\n//<![CDATA[\n", "\n//]]>\n" ]
-          when :both
-            [ "<!--\n//<![CDATA[\n", "\n//]]>\n//-->" ]
-          when nil
-          when Array
-            wrapper
-          else
-            raise ArgumentError, "Invalid JavaScript wrapper #{wrapper.inspect}"
-          end
-      end
-      def on_html_doctype(type)
-        type = type.to_s.downcase
-        if type =~ /^xml(\s+(.+))?$/
-          raise(FilterError, 'Invalid xml directive in html mode') if @format == :html
-          w = options[:attr_quote]
-          str = "<?xml version=#{w}1.0#{w} encoding=#{w}#{$2 || 'utf-8'}#{w} ?>"
-        else
-          str = DOCTYPES[@format][type] || raise(FilterError, "Invalid doctype #{type}")
-        end
-        [:static, str]
-      end
-      def on_html_comment(content)
-        [:multi,
-          [:static, '<!--'],
-          compile(content),
-          [:static, '-->']]
-      end
-      def on_html_condcomment(condition, content)
-        on_html_comment [:multi,
-                         [:static, "[#{condition}]>"],
-                         content,
-                         [:static, '<![endif]']]
-      end
-      def on_html_tag(name, attrs, content = nil)
-        name = name.to_s
-        closed = !content || (empty_exp?(content) && (@format == :xml || options[:autoclose].include?(name)))
-        result = [:multi, [:static, "<#{name}"], compile(attrs)]
-        result << [:static, (closed && @format != :html ? ' /' : '') + '>']
-        result << compile(content) if content
-        result << [:static, "</#{name}>"] if !closed
-        result
-      end
-      def on_html_attrs(*attrs)
-        [:multi, *attrs.map {|attr| compile(attr) }]
-      end
-      def on_html_attr(name, value)
-        if @format == :html && empty_exp?(value)
-          [:static, " #{name}"]
-        else
-          [:multi,
-           [:static, " #{name}=#{options[:attr_quote]}"],
-           compile(value),
-           [:static, options[:attr_quote]]]
-        end
-      end
-      def on_html_js(content)
-        if @js_wrapper
-          [:multi,
-           [:static, @js_wrapper.first],
-           compile(content),
-           [:static, @js_wrapper.last]]
-        else
-          compile(content)
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Temple
-  module HTML
-    # @api public
-    class Filter < Temple::Filter
-      include Dispatcher
-      def contains_nonempty_static?(exp)
-        case exp.first
-        when :multi
-          exp[1..-1].any? {|e| contains_nonempty_static?(e) }
-        when :escape
-          contains_nonempty_static?(exp.last)
-        when :static
-          !exp.last.empty?
-        else
-          false
-        end
-      end
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/html/pretty.rb DELETED Viewed

@@ -1,103 +0,0 @@
-module Temple
-  module HTML
-    # @api public
-    class Pretty < Fast
-      define_options indent: '  ',
-                     pretty: true,
-                     indent_tags: %w(article aside audio base body datalist dd div dl dt
-                                     fieldset figure footer form head h1 h2 h3 h4 h5 h6
-                                     header hgroup hr html li link meta nav ol option p
-                                     rp rt ruby section script style table tbody td tfoot
-                                     th thead tr ul video doctype).freeze,
-                     pre_tags: %w(code pre textarea).freeze
-      def initialize(opts = {})
-        super
-        @indent_next = nil
-        @indent = 0
-        @pretty = options[:pretty]
-        @pre_tags = @format != :xml && Regexp.union(options[:pre_tags].map {|t| "<#{t}" })
-      end
-      def call(exp)
-        @pretty ? [:multi, preamble, compile(exp)] : super
-      end
-      def on_static(content)
-        return [:static, content] unless @pretty
-        unless @pre_tags && @pre_tags =~ content
-          content = content.sub(/\A\s*\n?/, "\n".freeze) if @indent_next
-          content = content.gsub("\n".freeze, indent)
-        end
-        @indent_next = false
-        [:static, content]
-      end
-      def on_dynamic(code)
-        return [:dynamic, code] unless @pretty
-        indent_next, @indent_next = @indent_next, false
-        [:dynamic, "::Temple::Utils.indent_dynamic((#{code}), #{indent_next.inspect}, #{indent.inspect}#{@pre_tags ? ', ' + @pre_tags_name : ''})"]
-      end
-      def on_html_doctype(type)
-        return super unless @pretty
-        [:multi, [:static, tag_indent('doctype')], super]
-      end
-      def on_html_comment(content)
-        return super unless @pretty
-        result = [:multi, [:static, tag_indent('comment')], super]
-        @indent_next = false
-        result
-      end
-      def on_html_tag(name, attrs, content = nil)
-        return super unless @pretty
-        name = name.to_s
-        closed = !content || (empty_exp?(content) && options[:autoclose].include?(name))
-        @pretty = false
-        result = [:multi, [:static, "#{tag_indent(name)}<#{name}"], compile(attrs)]
-        result << [:static, (closed && @format != :html ? ' /' : '') + '>']
-        @pretty = !@pre_tags || !options[:pre_tags].include?(name)
-        if content
-          @indent += 1
-          result << compile(content)
-          @indent -= 1
-        end
-        unless closed
-          indent = tag_indent(name)
-          result << [:static, "#{content && !empty_exp?(content) ? indent : ''}</#{name}>"]
-        end
-        @pretty = true
-        result
-      end
-      protected
-      def preamble
-        return [:multi] unless @pre_tags
-        @pre_tags_name = unique_name
-        [:code, "#{@pre_tags_name} = /#{@pre_tags.source}/"]
-      end
-      def indent
-        "\n" + (options[:indent] || '') * @indent
-      end
-      # Return indentation before tag
-      def tag_indent(name)
-        if @format == :xml
-          flag = @indent_next != nil
-          @indent_next = true
-        else
-          flag = @indent_next != nil && (@indent_next || options[:indent_tags].include?(name))
-          @indent_next = options[:indent_tags].include?(name)
-        end
-        flag ? indent : ''
-      end
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/html/safe.rb DELETED Viewed

@@ -1,23 +0,0 @@
-module Temple
-  module HTML
-    class SafeString < String
-      def html_safe?; true end
-      def html_safe;  self end
-      def to_s;       self end
-    end
-  end
-end
-class Object
-  def html_safe?; false end
-end
-class Numeric
-  def html_safe?; true end
-end
-class String
-  def html_safe
-    Temple::HTML::SafeString.new(self)
-  end
-end

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

@@ -1,105 +0,0 @@
-module Temple
-  # Immutable map class which supports map merging
-  # @api public
-  class ImmutableMap
-    include Enumerable
-    def initialize(*map)
-      @map = map.compact
-    end
-    def include?(key)
-      @map.any? {|h| h.include?(key) }
-    end
-    def [](key)
-      @map.each {|h| return h[key] if h.include?(key) }
-      nil
-    end
-    def each
-      keys.each {|k| yield(k, self[k]) }
-    end
-    def keys
-      @map.inject([]) {|keys, h| keys.concat(h.keys) }.uniq
-    end
-    def values
-      keys.map {|k| self[k] }
-    end
-    def to_hash
-      result = {}
-      each {|k, v| result[k] = v }
-      result
-    end
-  end
-  # Mutable map class which supports map merging
-  # @api public
-  class MutableMap < ImmutableMap
-    def initialize(*map)
-      super({}, *map)
-    end
-    def []=(key, value)
-      @map.first[key] = value
-    end
-    def update(map)
-      @map.first.update(map)
-    end
-  end
-  class OptionMap < MutableMap
-    def initialize(*map, &block)
-      super(*map)
-      @handler = block
-      @valid = {}
-      @deprecated = {}
-    end
-    def []=(key, value)
-      validate_key!(key)
-      super
-    end
-    def update(map)
-      validate_map!(map)
-      super
-    end
-    def valid_keys
-      (keys + @valid.keys +
-       @map.map {|h| h.valid_keys if h.respond_to?(:valid_keys) }.compact.flatten).uniq
-    end
-    def add_valid_keys(*keys)
-      keys.flatten.each { |key| @valid[key] = true }
-    end
-    def add_deprecated_keys(*keys)
-      keys.flatten.each { |key| @valid[key] = @deprecated[key] = true }
-    end
-    def validate_map!(map)
-      map.to_hash.keys.each {|key| validate_key!(key) }
-    end
-    def validate_key!(key)
-      @handler.call(self, key, :deprecated) if deprecated_key?(key)
-      @handler.call(self, key, :invalid) unless valid_key?(key)
-    end
-    def deprecated_key?(key)
-      @deprecated.include?(key) ||
-        @map.any? {|h| h.deprecated_key?(key) if h.respond_to?(:deprecated_key?) }
-    end
-    def valid_key?(key)
-      include?(key) || @valid.include?(key) ||
-        @map.any? {|h| h.valid_key?(key) if h.respond_to?(:valid_key?) }
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/mixins/dispatcher.rb DELETED Viewed

@@ -1,161 +0,0 @@
-module Temple
-  module Mixins
-    # @api private
-    module CoreDispatcher
-      def on_multi(*exps)
-        multi = [:multi]
-        exps.each {|exp| multi << compile(exp) }
-        multi
-      end
-      def on_capture(name, exp)
-        [:capture, name, compile(exp)]
-      end
-    end
-    # @api private
-    module EscapeDispatcher
-      def on_escape(flag, exp)
-        [:escape, flag, compile(exp)]
-      end
-    end
-    # @api private
-    module ControlFlowDispatcher
-      def on_if(condition, *cases)
-        [:if, condition, *cases.compact.map {|e| compile(e) }]
-      end
-      def on_case(arg, *cases)
-        [:case, arg, *cases.map {|condition, exp| [condition, compile(exp)] }]
-      end
-      def on_block(code, content)
-        [:block, code, compile(content)]
-      end
-      def on_cond(*cases)
-        [:cond, *cases.map {|condition, exp| [condition, compile(exp)] }]
-      end
-    end
-    # @api private
-    module CompiledDispatcher
-      def call(exp)
-        compile(exp)
-      end
-      def compile(exp)
-        dispatcher(exp)
-      end
-      private
-      def dispatcher(exp)
-        replace_dispatcher(exp)
-      end
-      def replace_dispatcher(exp)
-        tree = DispatchNode.new
-        dispatched_methods.each do |method|
-          method.split('_'.freeze)[1..-1].inject(tree) {|node, type| node[type.to_sym] }.method = method
-        end
-        self.class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def dispatcher(exp)
-            return replace_dispatcher(exp) if self.class != #{self.class}
-            #{tree.compile.gsub("\n", "\n  ")}
-          end
-        RUBY
-        dispatcher(exp)
-      end
-      def dispatched_methods
-        re = /^on(_[a-zA-Z0-9]+)*$/
-        self.methods.map(&:to_s).select(&re.method(:=~))
-      end
-      # @api private
-      class DispatchNode < Hash
-        attr_accessor :method
-        def initialize
-          super { |hsh,key| hsh[key] = DispatchNode.new }
-          @method = nil
-        end
-        def compile(level = 0, call_parent = nil)
-          call_method = method ? (level == 0 ? "#{method}(*exp)" :
-                                  "#{method}(*exp[#{level}..-1])") : call_parent
-          if empty?
-            raise 'Invalid dispatcher node' unless method
-            call_method
-          else
-            code = String.new
-            code << "case(exp[#{level}])\n"
-            each do |key, child|
-              code << "when #{key.inspect}\n  " <<
-                child.compile(level + 1, call_method).gsub("\n".freeze, "\n  ".freeze) << "\n".freeze
-            end
-            code << "else\n  " << (call_method || 'exp') << "\nend"
-          end
-        end
-      end
-    end
-    # @api public
-    #
-    # Implements a compatible call-method
-    # based on the including classe's methods.
-    #
-    # It uses every method starting with
-    # "on" and uses the rest of the method
-    # name as prefix of the expression it
-    # will receive. So, if a dispatcher
-    # has a method named "on_x", this method
-    # will be called with arg0,..,argN
-    # whenever an expression like [:x, arg0,..,argN ]
-    # is encountered.
-    #
-    # This works with longer prefixes, too.
-    # For example a method named "on_y_z"
-    # will be called whenever an expression
-    # like [:y, :z, .. ] is found. Furthermore,
-    # if additionally a method named "on_y"
-    # is present, it will be called when an
-    # expression starts with :y but then does
-    # not contain with :z. This way a
-    # dispatcher can implement namespaces.
-    #
-    # @note
-    #  Processing does not reach into unknown
-    #  expression types by default.
-    #
-    # @example
-    #   class MyAwesomeDispatch
-    #     include Temple::Mixins::Dispatcher
-    #     def on_awesome(thing) # keep awesome things
-    #       return [:awesome, thing]
-    #     end
-    #     def on_boring(thing) # make boring things awesome
-    #       return [:awesome, thing+" with bacon"]
-    #     end
-    #     def on(type,*args) # unknown stuff is boring too
-    #       return [:awesome, 'just bacon']
-    #     end
-    #   end
-    #   filter = MyAwesomeDispatch.new
-    #   # Boring things are converted:
-    #   filter.call([:boring, 'egg']) #=> [:awesome, 'egg with bacon']
-    #   # Unknown things too:
-    #   filter.call([:foo]) #=> [:awesome, 'just bacon']
-    #   # Known but not boring things won't be touched:
-    #   filter.call([:awesome, 'chuck norris']) #=>[:awesome, 'chuck norris']
-    #
-    module Dispatcher
-      include CompiledDispatcher
-      include CoreDispatcher
-      include EscapeDispatcher
-      include ControlFlowDispatcher
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/temple-0.8.2/lib/temple/mixins/engine_dsl.rb DELETED Viewed

@@ -1,145 +0,0 @@
-module Temple
-  module Mixins
-    # @api private
-    module EngineDSL
-      def chain_modified!
-      end
-      def append(*args, &block)
-        chain << chain_element(args, block)
-        chain_modified!
-      end
-      def prepend(*args, &block)
-        chain.unshift(chain_element(args, block))
-        chain_modified!
-      end
-      def remove(name)
-        name = chain_name(name)
-        raise "#{name} not found" unless chain.reject! {|i| name === i.first }
-        chain_modified!
-      end
-      alias use append
-      def before(name, *args, &block)
-        name = chain_name(name)
-        e = chain_element(args, block)
-        chain.map! {|f| name === f.first ? [e, f] : [f] }.flatten!(1)
-        raise "#{name} not found" unless chain.include?(e)
-        chain_modified!
-      end
-      def after(name, *args, &block)
-        name = chain_name(name)
-        e = chain_element(args, block)
-        chain.map! {|f| name === f.first ? [f, e] : [f] }.flatten!(1)
-        raise "#{name} not found" unless chain.include?(e)
-        chain_modified!
-      end
-      def replace(name, *args, &block)
-        name = chain_name(name)
-        e = chain_element(args, block)
-        chain.map! {|f| name === f.first ? e : f }
-        raise "#{name} not found" unless chain.include?(e)
-        chain_modified!
-      end
-      # Shortcuts to access namespaces
-      { filter: Temple::Filters,
-        generator: Temple::Generators,
-        html: Temple::HTML }.each do |method, mod|
-        define_method(method) do |name, *options|
-          use(name, mod.const_get(name), *options)
-        end
-      end
-      private
-      def chain_name(name)
-        case name
-        when Class
-          name.name.to_sym
-        when Symbol, String
-          name.to_sym
-        when Regexp
-          name
-        else
-          raise(ArgumentError, 'Name argument must be Class, Symbol, String or Regexp')
-        end
-      end
-      def chain_class_constructor(filter, local_options)
-        define_options(filter.options.valid_keys) if respond_to?(:define_options) && filter.respond_to?(:options)
-        proc do |engine|
-          opts = {}.update(engine.options)
-          opts.delete_if {|k,v| !filter.options.valid_key?(k) } if filter.respond_to?(:options)
-          opts.update(local_options) if local_options
-          filter.new(opts)
-        end
-      end
-      def chain_proc_constructor(name, filter)
-        raise(ArgumentError, 'Proc or blocks must have arity 0 or 1') if filter.arity > 1
-        method_name = "FILTER #{name}"
-        c = Class === self ? self : singleton_class
-        filter = c.class_eval { define_method(method_name, &filter); instance_method(method_name) }
-        proc do |engine|
-          if filter.arity == 1
-            # the proc takes one argument, e.g. use(:Filter) {|exp| exp }
-            filter.bind(engine)
-          else
-            f = filter.bind(engine).call
-            if f.respond_to? :call
-              # the proc returns a callable object, e.g. use(:Filter) { Filter.new }
-              f
-            else
-              raise(ArgumentError, 'Proc or blocks must return a Callable or a Class') unless f.respond_to? :new
-              # the proc returns a class, e.g. use(:Filter) { Filter }
-              f.new(f.respond_to?(:options) ? engine.options.to_hash.select {|k,v| f.options.valid_key?(k) } : engine.options)
-            end
-          end
-        end
-      end
-      def chain_element(args, block)
-        name = args.shift
-        if Class === name
-          filter = name
-          name = filter.name.to_sym
-        else
-          raise(ArgumentError, 'Name argument must be Class or Symbol') unless Symbol === name
-        end
-        if block
-          raise(ArgumentError, 'Class and block argument are not allowed at the same time') if filter
-          filter = block
-        end
-        filter ||= args.shift
-        case filter
-        when Proc
-          # Proc or block argument
-          # The proc is converted to a method of the engine class.
-          # The proc can then access the option hash of the engine.
-          raise(ArgumentError, 'Too many arguments') unless args.empty?
-          [name, chain_proc_constructor(name, filter)]
-        when Class
-          # Class argument (e.g Filter class)
-          # The options are passed to the classes constructor.
-          raise(ArgumentError, 'Too many arguments') if args.size > 1
-          [name, chain_class_constructor(filter, args.first)]
-        else
-          # Other callable argument (e.g. Object of class which implements #call or Method)
-          # The callable has no access to the option hash of the engine.
-          raise(ArgumentError, 'Too many arguments') unless args.empty?
-          raise(ArgumentError, 'Class or callable argument is required') unless filter.respond_to?(:call)
-          [name, proc { filter }]
-        end
-      end
-    end
-  end
-end