brakeman 3.3.0 → 3.3.1

data/bundle/ruby/2.3.0/gems/{temple-0.7.6 → temple-0.7.7}/CHANGES

@@ -1,3 +1,8 @@
+0.7.7
+
+  * Add StaticAnalyzer, StringSplitter
+  * Freeze string literals
+
 0.7.6
 
   * EngineDSL - add support for use(:Filter) { FilterClassName }

data/bundle/ruby/2.3.0/gems/temple-0.7.7/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org/'
+gemspec
+gem 'escape_utils' if ENV['ESCAPE_UTILS']

data/bundle/ruby/2.3.0/gems/{temple-0.7.6 → temple-0.7.7}/lib/temple.rb

@@ -43,7 +43,9 @@ module Temple
     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'

data/bundle/ruby/2.3.0/gems/{temple-0.7.6 → temple-0.7.7}/lib/temple/filters/remove_bom.rb

@@ -6,7 +6,7 @@ module Temple
     class RemoveBOM < Parser
       def call(s)
         return s if s.encoding.name !~ /^UTF-(8|16|32)(BE|LE)?/
-        s.gsub(Regexp.new("\\A\uFEFF".encode(s.encoding.name)), '')
+        s.gsub(Regexp.new("\\A\uFEFF".encode(s.encoding.name)), ''.freeze)
       end
     end
   end

data/bundle/ruby/2.3.0/gems/temple-0.7.7/lib/temple/filters/static_analyzer.rb

@@ -0,0 +1,87 @@
+begin
+  require 'ripper'
+rescue LoadError
+end
+
+module Temple
+  module Filters
+    # Convert [:dynamic, code] to [:static, text] if code is static Ruby expression.
+    class StaticAnalyzer < Filter
+      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,
+      ].freeze
+
+      DYNAMIC_TOKENS = [
+        :on_ident, :on_period,
+      ].freeze
+
+      STATIC_KEYWORDS = [
+        'true', 'false', 'nil',
+      ].freeze
+
+      STATIC_OPERATORS = [
+        '=>',
+      ].freeze
+
+      if defined?(Ripper)
+        def self.static?(code)
+          return false if code.nil? || code.strip.empty?
+          return false if SyntaxChecker.syntax_error?(code)
+
+          Ripper.lex(code).each do |(_, col), 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 on_dynamic(code)
+          if StaticAnalyzer.static?(code)
+            [:static, eval(code).to_s]
+          else
+            [:dynamic, code]
+          end
+        end
+
+        class SyntaxChecker < Ripper
+          class ParseError < StandardError; end
+
+          def self.syntax_error?(code)
+            self.new(code).parse
+            false
+          rescue ParseError
+            true
+          end
+
+          private
+
+          def on_parse_error(*)
+            raise ParseError
+          end
+        end
+      else
+        # Do nothing if ripper is unavailable
+        def call(ast)
+          ast
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/2.3.0/gems/temple-0.7.7/lib/temple/filters/string_splitter.rb

@@ -0,0 +1,130 @@
+begin
+  require 'ripper'
+rescue LoadError
+end
+
+module Temple
+  module Filters
+    # Compile [:dynamic, "foo#{bar}"] to [:multi, [:static, 'foo'], [:dynamic, 'bar']]
+    class StringSplitter < Filter
+      if defined?(Ripper) && RUBY_VERSION >= "2.0.0"
+        class << self
+          # `code` param must be valid string literal
+          def compile(code)
+            [].tap do |exps|
+              tokens = Ripper.lex(code.strip)
+              tokens.pop while tokens.last && [:on_comment, :on_sp].include?(tokens.last[1])
+
+              if tokens.size < 2
+                raise "Expected token size >= 2 but got: #{tokens.size}"
+              end
+              compile_tokens!(exps, tokens)
+            end
+          end
+
+          private
+
+          def strip_quotes!(tokens)
+            _, type, beg_str = tokens.shift
+            if type != :on_tstring_beg
+              raise "Expected :on_tstring_beg but got: #{type}"
+            end
+
+            _, type, end_str = tokens.pop
+            if type != :on_tstring_end
+              raise "Expected :on_tstring_end but got: #{type}"
+            end
+
+            [beg_str, end_str]
+          end
+
+          def compile_tokens!(exps, tokens)
+            beg_str, end_str = strip_quotes!(tokens)
+
+            until tokens.empty?
+              _, type, str = tokens.shift
+
+              case type
+              when :on_tstring_content
+                exps << [:static, eval("#{beg_str}#{str}#{end_str}").to_s]
+              when :on_embexpr_beg
+                embedded = shift_balanced_embexpr(tokens)
+                exps << [:dynamic, embedded] unless embedded.empty?
+              end
+            end
+          end
+
+          def shift_balanced_embexpr(tokens)
+            String.new.tap do |embedded|
+              embexpr_open = 1
+
+              until tokens.empty?
+                _, type, str = tokens.shift
+                case type
+                when :on_embexpr_beg
+                  embexpr_open += 1
+                when :on_embexpr_end
+                  embexpr_open -= 1
+                  break if embexpr_open == 0
+                end
+
+                embedded << str
+              end
+            end
+          end
+        end
+
+        def on_dynamic(code)
+          return [:dynamic, code] unless string_literal?(code)
+          return [:dynamic, code] if code.include?("\n")
+
+          temple = [:multi]
+          StringSplitter.compile(code).each do |type, content|
+            case type
+            when :static
+              temple << [:static, content]
+            when :dynamic
+              temple << on_dynamic(content)
+            end
+          end
+          temple
+        end
+
+        private
+
+        def string_literal?(code)
+          return false if SyntaxChecker.syntax_error?(code)
+
+          type, instructions = Ripper.sexp(code)
+          return false if type != :program
+          return false if instructions.size > 1
+
+          type, _ = instructions.first
+          type == :string_literal
+        end
+
+        class SyntaxChecker < Ripper
+          class ParseError < StandardError; end
+
+          def self.syntax_error?(code)
+            self.new(code).parse
+            false
+          rescue ParseError
+            true
+          end
+
+          private
+
+          def on_parse_error(*)
+            raise ParseError
+          end
+        end
+      else
+        # Do nothing if ripper is unavailable
+        def call(ast)
+          ast
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/2.3.0/gems/{temple-0.7.6 → temple-0.7.7}/lib/temple/generator.rb

@@ -46,7 +46,7 @@ module Temple
     end
 
     def on_multi(*exp)
-      exp.map {|e| compile(e) }.join('; ')
+      exp.map {|e| compile(e) }.join('; '.freeze)
     end
 
     def on_newline

data/bundle/ruby/2.3.0/gems/{temple-0.7.6 → temple-0.7.7}/lib/temple/generators/array_buffer.rb

@@ -5,7 +5,7 @@ module Temple
     #   _buf = []
     #   _buf << "static"
     #   _buf << dynamic
-    #   _buf.join
+    #   _buf.join("")
     #
     # @api public
     class ArrayBuffer < Array
@@ -21,7 +21,8 @@ module Temple
       end
 
       def return_buffer
-        "#{buffer} = #{buffer}.join"
+        freeze = options[:freeze_static] ? '.freeze' : ''
+        "#{buffer} = #{buffer}.join(\"\"#{freeze})"
       end
     end
   end

data/bundle/ruby/2.3.0/gems/{temple-0.7.6 → temple-0.7.7}/lib/temple/generators/erb.rb

@@ -9,7 +9,7 @@ module Temple
       end
 
       def on_multi(*exp)
-        exp.map {|e| compile(e) }.join
+        exp.map {|e| compile(e) }.join('')
       end
 
       def on_capture(name, exp)

data/bundle/ruby/2.3.0/gems/{temple-0.7.6 → temple-0.7.7}/lib/temple/generators/rails_output_buffer.rb

@@ -16,7 +16,7 @@ module Temple
                      capture_generator: RailsOutputBuffer
 
       def call(exp)
-        [preamble, compile(exp), postamble].flatten.compact.join('; ')
+        [preamble, compile(exp), postamble].flatten.compact.join('; '.freeze)
       end
 
       def create_buffer

data/bundle/ruby/2.3.0/gems/{temple-0.7.6 → temple-0.7.7}/lib/temple/html/attribute_merger.rb

@@ -6,40 +6,35 @@ module Temple
       define_options merge_attrs: {'id' => '_', 'class' => ' '}
 
       def on_html_attrs(*attrs)
-        names = []
         values = {}
 
-        attrs.each do |attr|
-          name, value = attr[2].to_s, attr[3]
+        attrs.each do |_, _, name, value|
+          name = name.to_s
           if values[name]
             raise(FilterError, "Multiple #{name} attributes specified") unless options[:merge_attrs][name]
             values[name] << value
           else
             values[name] = [value]
-            names << name
           end
         end
 
-        attrs = names.map do |name|
-          value = values[name]
+        attrs = values.map do |name, value|
           if (delimiter = options[:merge_attrs][name]) && value.size > 1
             exp = [:multi]
             if value.all? {|v| contains_nonempty_static?(v) }
               exp << value.first
               value[1..-1].each {|v| exp << [:static, delimiter] << v }
-              [:html, :attr, name, exp]
             else
               captures = unique_name
               exp << [:code, "#{captures} = []"]
               value.each_with_index {|v, i| exp << [:capture, "#{captures}[#{i}]", v] }
               exp << [:dynamic, "#{captures}.reject(&:empty?).join(#{delimiter.inspect})"]
             end
-            [:html, :attr, name, exp]
           else
-            [:html, :attr, name, value.first]
+            exp = value.first
           end
+          [:html, :attr, name, exp]
         end
-
         [:html, :attrs, *attrs]
       end
     end

data/bundle/ruby/2.3.0/gems/{temple-0.7.6 → temple-0.7.7}/lib/temple/html/pretty.rb

@@ -26,8 +26,8 @@ module Temple
       def on_static(content)
         return [:static, content] unless @pretty
         unless @pre_tags && @pre_tags =~ content
-          content = content.sub(/\A\s*\n?/, "\n") if @indent_next
-          content = content.gsub("\n", indent)
+          content = content.sub(/\A\s*\n?/, "\n".freeze) if @indent_next
+          content = content.gsub("\n".freeze, indent)
         end
         @indent_next = false
         [:static, content]

data/bundle/ruby/2.3.0/gems/{temple-0.7.6 → temple-0.7.7}/lib/temple/mixins/dispatcher.rb

@@ -58,12 +58,14 @@ module Temple
       def replace_dispatcher(exp)
         tree = DispatchNode.new
         dispatched_methods.each do |method|
-          method.split('_')[1..-1].inject(tree) {|node, type| node[type.to_sym] }.method = method
+          method.split('_'.freeze)[1..-1].inject(tree) {|node, type| node[type.to_sym] }.method = method
         end
-        self.class.class_eval %{def dispatcher(exp)
-  return replace_dispatcher(exp) if self.class != #{self.class}
-  #{tree.compile.gsub("\n", "\n  ")}
-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
 
@@ -91,7 +93,7 @@ end}
             code = "case(exp[#{level}])\n"
             each do |key, child|
               code << "when #{key.inspect}\n  " <<
-                child.compile(level + 1, call_method).gsub("\n", "\n  ") << "\n"
+                child.compile(level + 1, call_method).gsub("\n".freeze, "\n  ".freeze) << "\n".freeze
             end
             code << "else\n  " << (call_method || 'exp') << "\nend"
           end