brakeman 7.1.2 → 8.0.0

data/bundle/ruby/3.2.0/gems/erubis-2.7.0/lib/erubis/converter.rb

@@ -1,357 +0,0 @@
-##
-## $Release: 2.7.0 $
-## copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
-##
-
-require 'erubis/util'
-
-module Erubis
-
-
-  ##
-  ## convert
-  ##
-  module Converter
-
-    attr_accessor :preamble, :postamble, :escape
-
-    def self.supported_properties    # :nodoc:
-      return [
-              [:preamble,  nil,    "preamble (no preamble when false)"],
-              [:postamble, nil,    "postamble (no postamble when false)"],
-              [:escape,    nil,    "escape expression or not in default"],
-             ]
-    end
-
-    def init_converter(properties={})
-      @preamble  = properties[:preamble]
-      @postamble = properties[:postamble]
-      @escape    = properties[:escape]
-    end
-
-    ## convert input string into target language
-    def convert(input)
-      codebuf = ""    # or []
-      @preamble.nil? ? add_preamble(codebuf) : (@preamble && (codebuf << @preamble))
-      convert_input(codebuf, input)
-      @postamble.nil? ? add_postamble(codebuf) : (@postamble && (codebuf << @postamble))
-      @_proc = nil    # clear cached proc object
-      return codebuf  # or codebuf.join()
-    end
-
-    protected
-
-    ##
-    ## detect spaces at beginning of line
-    ##
-    def detect_spaces_at_bol(text, is_bol)
-      lspace = nil
-      if text.empty?
-        lspace = "" if is_bol
-      elsif text[-1] == ?\n
-        lspace = ""
-      else
-        rindex = text.rindex(?\n)
-        if rindex
-          s = text[rindex+1..-1]
-          if s =~ /\A[ \t]*\z/
-            lspace = s
-            #text = text[0..rindex]
-            text[rindex+1..-1] = ''
-          end
-        else
-          if is_bol && text =~ /\A[ \t]*\z/
-            #lspace = text
-            #text = nil
-            lspace = text.dup
-            text[0..-1] = ''
-          end
-        end
-      end
-      return lspace
-    end
-
-    ##
-    ## (abstract) convert input to code
-    ##
-    def convert_input(codebuf, input)
-      not_implemented
-    end
-
-  end
-
-
-  module Basic
-  end
-
-
-  ##
-  ## basic converter which supports '<% ... %>' notation.
-  ##
-  module Basic::Converter
-    include Erubis::Converter
-
-    def self.supported_properties    # :nodoc:
-      return [
-              [:pattern,  '<% %>', "embed pattern"],
-              [:trim,      true,   "trim spaces around <% ... %>"],
-             ]
-    end
-
-    attr_accessor :pattern, :trim
-
-    def init_converter(properties={})
-      super(properties)
-      @pattern = properties[:pattern]
-      @trim    = properties[:trim] != false
-    end
-
-    protected
-
-    ## return regexp of pattern to parse eRuby script
-    def pattern_regexp(pattern)
-      @prefix, @postfix = pattern.split()   # '<% %>' => '<%', '%>'
-      #return /(.*?)(^[ \t]*)?#{@prefix}(=+|\#)?(.*?)-?#{@postfix}([ \t]*\r?\n)?/m
-      #return /(^[ \t]*)?#{@prefix}(=+|\#)?(.*?)-?#{@postfix}([ \t]*\r?\n)?/m
-      return /#{@prefix}(=+|-|\#|%)?(.*?)([-=])?#{@postfix}([ \t]*\r?\n)?/m
-    end
-    module_function :pattern_regexp
-
-    #DEFAULT_REGEXP = /(.*?)(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
-    #DEFAULT_REGEXP = /(^[ \t]*)?<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
-    #DEFAULT_REGEXP = /<%(=+|\#)?(.*?)-?%>([ \t]*\r?\n)?/m
-    DEFAULT_REGEXP = pattern_regexp('<% %>')
-
-    public
-
-    def convert_input(src, input)
-      pat = @pattern
-      regexp = pat.nil? || pat == '<% %>' ? DEFAULT_REGEXP : pattern_regexp(pat)
-      pos = 0
-      is_bol = true     # is beginning of line
-      input.scan(regexp) do |indicator, code, tailch, rspace|
-        match = Regexp.last_match()
-        len  = match.begin(0) - pos
-        text = input[pos, len]
-        pos  = match.end(0)
-        ch   = indicator ? indicator[0] : nil
-        lspace = ch == ?= ? nil : detect_spaces_at_bol(text, is_bol)
-        is_bol = rspace ? true : false
-        add_text(src, text) if text && !text.empty?
-        ## * when '<%= %>', do nothing
-        ## * when '<% %>' or '<%# %>', delete spaces iff only spaces are around '<% %>'
-        if ch == ?=              # <%= %>
-          rspace = nil if tailch && !tailch.empty?
-          add_text(src, lspace) if lspace
-          add_expr(src, code, indicator)
-          add_text(src, rspace) if rspace
-        elsif ch == ?\#          # <%# %>
-          n = code.count("\n") + (rspace ? 1 : 0)
-          if @trim && lspace && rspace
-            add_stmt(src, "\n" * n)
-          else
-            add_text(src, lspace) if lspace
-            add_stmt(src, "\n" * n)
-            add_text(src, rspace) if rspace
-          end
-        elsif ch == ?%           # <%% %>
-          s = "#{lspace}#{@prefix||='<%'}#{code}#{tailch}#{@postfix||='%>'}#{rspace}"
-          add_text(src, s)
-        else                     # <% %>
-          if @trim && lspace && rspace
-            add_stmt(src, "#{lspace}#{code}#{rspace}")
-          else
-            add_text(src, lspace) if lspace
-            add_stmt(src, code)
-            add_text(src, rspace) if rspace
-          end
-        end
-      end
-      #rest = $' || input                        # ruby1.8
-      rest = pos == 0 ? input : input[pos..-1]   # ruby1.9
-      add_text(src, rest)
-    end
-
-    ## add expression code to src
-    def add_expr(src, code, indicator)
-      case indicator
-      when '='
-        @escape ? add_expr_escaped(src, code) : add_expr_literal(src, code)
-      when '=='
-        @escape ? add_expr_literal(src, code) : add_expr_escaped(src, code)
-      when '==='
-        add_expr_debug(src, code)
-      end
-    end
-
-  end
-
-
-  module PI
-  end
-
-  ##
-  ## Processing Instructions (PI) converter for XML.
-  ## this class converts '<?rb ... ?>' and '${...}' notation.
-  ##
-  module PI::Converter
-    include Erubis::Converter
-
-    def self.desc   # :nodoc:
-      "use processing instructions (PI) instead of '<% %>'"
-    end
-
-    def self.supported_properties    # :nodoc:
-      return [
-              [:trim,      true,   "trim spaces around <% ... %>"],
-              [:pi,        'rb',   "PI (Processing Instrunctions) name"],
-              [:embchar,   '@',    "char for embedded expression pattern('@{...}@')"],
-              [:pattern,  '<% %>', "embed pattern"],
-             ]
-    end
-
-    attr_accessor :pi, :prefix
-
-    def init_converter(properties={})
-      super(properties)
-      @trim    = properties.fetch(:trim, true)
-      @pi      = properties[:pi] if properties[:pi]
-      @embchar = properties[:embchar] || '@'
-      @pattern = properties[:pattern]
-      @pattern = '<% %>' if @pattern.nil?  #|| @pattern == true
-    end
-
-    def convert(input)
-      code = super(input)
-      return @header || @footer ? "#{@header}#{code}#{@footer}" : code
-    end
-
-    protected
-
-    def convert_input(codebuf, input)
-      unless @regexp
-        @pi ||= 'e'
-        ch = Regexp.escape(@embchar)
-        if @pattern
-          left, right = @pattern.split(' ')
-          @regexp = /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/m
-        else
-          @regexp = /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?|#{ch}(!*)?\{(.*?)\}#{ch}/m
-        end
-      end
-      #
-      is_bol = true
-      pos = 0
-      input.scan(@regexp) do |pi_arg, stmt, rspace,
-                              indicator1, expr1, indicator2, expr2|
-        match = Regexp.last_match
-        len = match.begin(0) - pos
-        text = input[pos, len]
-        pos = match.end(0)
-        lspace = stmt ? detect_spaces_at_bol(text, is_bol) : nil
-        is_bol = stmt && rspace ? true : false
-        add_text(codebuf, text) # unless text.empty?
-        #
-        if stmt
-          if @trim && lspace && rspace
-            add_pi_stmt(codebuf, "#{lspace}#{stmt}#{rspace}", pi_arg)
-          else
-            add_text(codebuf, lspace) if lspace
-            add_pi_stmt(codebuf, stmt, pi_arg)
-            add_text(codebuf, rspace) if rspace
-          end
-        else
-          add_pi_expr(codebuf, expr1 || expr2, indicator1 || indicator2)
-        end
-      end
-      #rest = $' || input                        # ruby1.8
-      rest = pos == 0 ? input : input[pos..-1]   # ruby1.9
-      add_text(codebuf, rest)
-    end
-
-    #--
-    #def convert_input(codebuf, input)
-    #  parse_stmts(codebuf, input)
-    #  #parse_stmts2(codebuf, input)
-    #end
-    #
-    #def parse_stmts(codebuf, input)
-    #  #regexp = pattern_regexp(@pattern)
-    #  @pi ||= 'e'
-    #  @stmt_pattern ||= /<\?#{@pi}(?:-(\w+))?(\s.*?)\?>([ \t]*\r?\n)?/m
-    #  is_bol = true
-    #  pos = 0
-    #  input.scan(@stmt_pattern) do |pi_arg, code, rspace|
-    #    match = Regexp.last_match
-    #    len  = match.begin(0) - pos
-    #    text = input[pos, len]
-    #    pos  = match.end(0)
-    #    lspace = detect_spaces_at_bol(text, is_bol)
-    #    is_bol = rspace ? true : false
-    #    parse_exprs(codebuf, text) # unless text.empty?
-    #    if @trim && lspace && rspace
-    #      add_pi_stmt(codebuf, "#{lspace}#{code}#{rspace}", pi_arg)
-    #    else
-    #      add_text(codebuf, lspace)
-    #      add_pi_stmt(codebuf, code, pi_arg)
-    #      add_text(codebuf, rspace)
-    #    end
-    #  end
-    #  rest = $' || input
-    #  parse_exprs(codebuf, rest)
-    #end
-    #
-    #def parse_exprs(codebuf, input)
-    #  unless @expr_pattern
-    #    ch = Regexp.escape(@embchar)
-    #    if @pattern
-    #      left, right = @pattern.split(' ')
-    #      @expr_pattern = /#{ch}(!*)?\{(.*?)\}#{ch}|#{left}(=+)(.*?)#{right}/
-    #    else
-    #      @expr_pattern = /#{ch}(!*)?\{(.*?)\}#{ch}/
-    #    end
-    #  end
-    #  pos = 0
-    #  input.scan(@expr_pattern) do |indicator1, code1, indicator2, code2|
-    #    indicator = indicator1 || indicator2
-    #    code = code1 || code2
-    #    match = Regexp.last_match
-    #    len  = match.begin(0) - pos
-    #    text = input[pos, len]
-    #    pos  = match.end(0)
-    #    add_text(codebuf, text) # unless text.empty?
-    #    add_pi_expr(codebuf, code, indicator)
-    #  end
-    #  rest = $' || input
-    #  add_text(codebuf, rest)
-    #end
-    #++
-
-    def add_pi_stmt(codebuf, code, pi_arg)  # :nodoc:
-      case pi_arg
-      when nil      ;  add_stmt(codebuf, code)
-      when 'header' ;  @header = code
-      when 'footer' ;  @footer = code
-      when 'comment';  add_stmt(codebuf, "\n" * code.count("\n"))
-      when 'value'  ;  add_expr_literal(codebuf, code)
-      else          ;  add_stmt(codebuf, code)
-      end
-    end
-
-    def add_pi_expr(codebuf, code, indicator)  # :nodoc:
-      case indicator
-      when nil, '', '=='    # @{...}@ or <%== ... %>
-        @escape == false ? add_expr_literal(codebuf, code) : add_expr_escaped(codebuf, code)
-      when '!', '='         # @!{...}@ or <%= ... %>
-        @escape == false ? add_expr_escaped(codebuf, code) : add_expr_literal(codebuf, code)
-      when '!!', '==='      # @!!{...}@ or <%=== ... %>
-        add_expr_debug(codebuf, code)
-      else
-        # ignore
-      end
-    end
-
-  end
-
-
-end

data/bundle/ruby/3.2.0/gems/erubis-2.7.0/lib/erubis/engine/ec.rb

@@ -1,117 +0,0 @@
-##
-## $Release: 2.7.0 $
-## copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
-##
-
-require 'erubis/engine'
-require 'erubis/enhancer'
-
-
-module Erubis
-
-
-  module CGenerator
-    include Generator
-
-    def self.supported_properties()  # :nodoc:
-      return [
-              [:indent, '',       "indent spaces (ex. '  ')"],
-              [:out,    'stdout', "output file pointer name"],
-            ]
-    end
-
-    def init_generator(properties={})
-      super
-      @escapefunc ||= "escape"
-      @indent = properties[:indent] || ''
-      @out = properties[:out] || 'stdout'
-    end
-
-    def add_preamble(src)
-      src << "#line 1 \"#{self.filename}\"\n" if self.filename
-    end
-
-    def escape_text(text)
-      @@table_ ||= { "\r"=>"\\r", "\n"=>"\\n", "\t"=>"\\t", '"'=>'\\"', "\\"=>"\\\\" }
-      text.gsub!(/[\r\n\t"\\]/) { |m| @@table_[m] }
-      return text
-    end
-
-    def escaped_expr(code)
-      return "#{@escapefunc}(#{code.strip}, #{@out})"
-    end
-
-    def add_text(src, text)
-      return if text.empty?
-      src << (src.empty? || src[-1] == ?\n ? @indent : ' ')
-      src << "fputs("
-      i = 0
-      text.each_line do |line|
-        src << "\n" << @indent << '      ' if i > 0
-        i += 1
-        src << '"' << escape_text(line) << '"'
-      end
-      src << ", #{@out});"   #<< (text[-1] == ?\n ? "\n" : "")
-      src << "\n" if text[-1] == ?\n
-    end
-
-    def add_stmt(src, code)
-      src << code
-    end
-
-    def add_expr_literal(src, code)
-      src << @indent if src.empty? || src[-1] == ?\n
-      src << " fprintf(#{@out}, " << code.strip << ');'
-    end
-
-    def add_expr_escaped(src, code)
-      src << @indent if src.empty? || src[-1] == ?\n
-      src << ' ' << escaped_expr(code) << ';'
-    end
-
-    def add_expr_debug(src, code)
-      code.strip!
-      s = nil
-      if code =~ /\A\".*?\"\s*,\s*(.*)/
-        s = $1.gsub(/[%"]/, '\\\1') + '='
-      end
-      src << @indent if src.empty? || src[-1] == ?\n
-      src << " fprintf(stderr, \"*** debug: #{s}\" #{code});"
-    end
-
-    def add_postamble(src)
-      # empty
-    end
-
-  end
-
-
-  ##
-  ## engine for C
-  ##
-  class Ec < Basic::Engine
-    include CGenerator
-  end
-
-
-  class EscapedEc < Ec
-    include EscapeEnhancer
-  end
-
-
-  #class XmlEc < Ec
-  #  include EscapeEnhancer
-  #end
-
-  class PI::Ec < PI::Engine
-    include CGenerator
-
-    def init_converter(properties={})
-      @pi = 'c'
-      super(properties)
-    end
-
-  end
-
-
-end

data/bundle/ruby/3.2.0/gems/erubis-2.7.0/lib/erubis/engine/ecpp.rb

@@ -1,113 +0,0 @@
-##
-## $Release: 2.7.0 $
-## copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
-##
-
-require 'erubis/engine'
-require 'erubis/enhancer'
-
-
-module Erubis
-
-
-  module CppGenerator
-    include Generator
-
-    def self.supported_properties()  # :nodoc:
-      return [
-              [:indent, '',       "indent spaces (ex. '  ')"],
-              [:bufvar, '_buf',   "buffer variable name"],
-            ]
-    end
-
-    def init_generator(properties={})
-      super
-      @escapefunc ||= "escape"
-      @indent = properties[:indent] || ''
-      @bufvar = properties[:bufvar] || '_buf'
-    end
-
-    def add_preamble(src)
-      src << "#line 1 \"#{self.filename}\"\n" if self.filename
-    end
-
-    def escape_text(text)
-      @@table_ ||= { "\r"=>"\\r", "\n"=>"\\n", "\t"=>"\\t", '"'=>'\\"', "\\"=>"\\\\" }
-      text.gsub!(/[\r\n\t"\\]/) { |m| @@table_[m] }
-      return text
-    end
-
-    def escaped_expr(code)
-      return "#{@escapefunc}(#{code.strip})"
-    end
-
-    def add_text(src, text)
-      return if text.empty?
-      src << (src.empty? || src[-1] == ?\n ? @indent : ' ')
-      src << "_buf << "
-      i = 0
-      text.each_line do |line|
-        src << "\n" << @indent << "        " if i > 0
-        i += 1
-        src << '"' << escape_text(line) << '"'
-      end
-      src << ";"   #<< (text[-1] == ?\n ? "\n" : "")
-      src << "\n" if text[-1] == ?\n
-    end
-
-    def add_stmt(src, code)
-      src << code
-    end
-
-    def add_expr_literal(src, code)
-      src << @indent if src.empty? || src[-1] == ?\n
-      src << " _buf << (" << code.strip << ");"
-    end
-
-    def add_expr_escaped(src, code)
-      src << @indent if src.empty? || src[-1] == ?\n
-      src << ' ' << escaped_expr(code) << ';'
-    end
-
-    def add_expr_debug(src, code)
-      code.strip!
-      src << @indent if src.empty? || src[-1] == ?\n
-      src << " std::cerr << \"*** debug: #{code.gsub(/(")/, '\\\&')}=\" << (#{code});"
-    end
-
-    def add_postamble(src)
-      # empty
-    end
-
-  end
-
-
-  ##
-  ## engine for C
-  ##
-  class Ecpp < Basic::Engine
-    include CppGenerator
-  end
-
-
-  class EscapedEcpp < Ecpp
-    include EscapeEnhancer
-  end
-
-
-  #class XmlEcpp < Ecpp
-  #  include EscapeEnhancer
-  #end
-
-  class PI::Ecpp < PI::Engine
-    include CppGenerator
-
-    def init_converter(properties={})
-      @pi = 'cpp'
-      super(properties)
-    end
-
-  end
-
-
-end

data/bundle/ruby/3.2.0/gems/erubis-2.7.0/lib/erubis/engine/ejava.rb

@@ -1,110 +0,0 @@
-##
-## $Release: 2.7.0 $
-## copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
-##
-
-require 'erubis/engine'
-require 'erubis/enhancer'
-
-
-module Erubis
-
-
-  module JavaGenerator
-    include Generator
-
-    def self.supported_properties()   # :nodoc:
-      return [
-              [:indent,   '',       "indent spaces (ex. '  ')"],
-              [:bufvar,   '_buf',   "output buffer variable name"],
-              [:bufclass, 'StringBuffer', "output buffer class (ex. 'StringBuilder')"],
-            ]
-    end
-
-    def init_generator(properties={})
-      super
-      @escapefunc ||= 'escape'
-      @indent = properties[:indent] || ''
-      @bufvar = properties[:bufvar] || '_buf'
-      @bufclass = properties[:bufclass] || 'StringBuffer'
-    end
-
-    def add_preamble(src)
-      src << "#{@indent}#{@bufclass} #{@bufvar} = new #{@bufclass}();"
-    end
-
-    def escape_text(text)
-      @@table_ ||= { "\r"=>"\\r", "\n"=>"\\n", "\t"=>"\\t", '"'=>'\\"', "\\"=>"\\\\" }
-      return text.gsub!(/[\r\n\t"\\]/) { |m| @@table_[m] } || text
-    end
-
-    def add_text(src, text)
-      return if text.empty?
-      src << (src.empty? || src[-1] == ?\n ? @indent : ' ')
-      src << @bufvar << ".append("
-      i = 0
-      text.each_line do |line|
-        src << "\n" << @indent << '          + ' if i > 0
-        i += 1
-        src << '"' << escape_text(line) << '"'
-      end
-      src << ");" << (text[-1] == ?\n ? "\n" : "")
-    end
-
-    def add_stmt(src, code)
-      src << code
-    end
-
-    def add_expr_literal(src, code)
-      src << @indent if src.empty? || src[-1] == ?\n
-      code.strip!
-      src << " #{@bufvar}.append(#{code});"
-    end
-
-    def add_expr_escaped(src, code)
-      add_expr_literal(src, escaped_expr(code))
-    end
-
-    def add_expr_debug(src, code)
-      code.strip!
-      src << @indent if src.empty? || src[-1] == ?\n
-      src << " System.err.println(\"*** debug: #{code}=\"+(#{code}));"
-    end
-
-    def add_postamble(src)
-      src << "\n" if src[-1] == ?;
-      src << @indent << "return " << @bufvar << ".toString();\n"
-      #src << @indent << "System.out.print(" << @bufvar << ".toString());\n"
-    end
-
-  end
-
-
-  ##
-  ## engine for Java
-  ##
-  class Ejava < Basic::Engine
-    include JavaGenerator
-  end
-
-
-  class EscapedEjava < Ejava
-    include EscapeEnhancer
-  end
-
-
-  #class XmlEjava < Ejava
-  #  include EscapeEnhancer
-  #end
-
-  class PI::Ejava < PI::Engine
-    include JavaGenerator
-
-    def init_converter(properties={})
-      @pi = 'java'
-      super(properties)
-    end
-
-  end
-
-end