brakeman 3.7.0 → 3.7.1

data/bundle/ruby/2.3.0/gems/{sexp_processor-4.9.0 → sexp_processor-4.10.0}/test/test_sexp_processor.rb

@@ -1,78 +1,86 @@
 $TESTING = true
 
-require 'sexp_processor'
-require 'stringio'
-require 'minitest/autorun'
-require 'pp'
+if ENV["COV"]
+  require "simplecov"
+  SimpleCov.start do
+    add_filter "lib/sexp.rb"
+    add_filter "test"
+  end
+  warn "Running simplecov"
+end
+
+require "sexp_processor"
+require "stringio"
+require "minitest/autorun"
+require "pp"
 
 # Fake test classes:
 
 class TestProcessor < SexpProcessor # ZenTest SKIP
   attr_accessor :auto_shift_type
 
-  def process_acc1(exp)
+  def initialize
+    super
+    self.require_empty = false
+    self.auto_shift_type = false
+  end
+
+  def process_acc1 exp
     out = self.expected.new(:acc2, exp.thing_three, exp.thing_two, exp.thing_one)
     exp.clear
-    return out
+    out
   end
 
-  def process_acc2(exp)
-    out = []
+  def process_acc2 exp
+    out = s()
     out << exp.thing_one
   end
 
-  def process_specific(exp)
-    _ = exp.shift
-    result = s(:blah)
-    until exp.empty?
-      result.push process(exp.shift)
-    end
-    result
+  def process_specific exp
+    _, *data = exp
+    s(:blah, *data.map { |x| process x })
   end
 
-  def process_strip(exp)
-    result = exp.deep_clone
-    exp.clear
-    result
+  def process_strip exp
+    exp.deep_clone
   end
 
-  def process_nonempty(exp)
+  def process_nonempty exp
     s(*exp)
   end
 
-  def process_broken(exp)
+  def process_broken exp
     result = [*exp]
     exp.clear
     result
   end
 
-  def process_expected(exp)
+  def process_expected exp
     exp.clear
-    return {}
+    {}
   end
 
-  def process_string(exp)
-    return exp.shift
+  def process_string exp
+    exp.sexp_type
   end
 
-  def rewrite_rewritable(exp) # (a b c) => (a c b)
-    return s(exp.shift, exp.pop, exp.shift)
+  def rewrite_rewritable exp # (a b c) => (a c b)
+    a, b, c = exp
+    s(a, c, b)
   end
 
-  def process_rewritable(exp)
+  def process_rewritable exp
+    _, *data = exp
+
     @n ||= 0
-    exp.shift # name
-    result = s(:rewritten)
-    until exp.empty?
-      result.push process(exp.shift)
-    end
-    result.push @n
+    result = s(:rewritten, *data.map { |x| process x }, @n)
     @n += 1
+
     result
   end
 
-  def rewrite_major_rewrite(exp)
-    exp[0] = :rewritable
+  def rewrite_major_rewrite exp
+    exp.sexp_type = :rewritable
     exp
   end
 end
@@ -83,7 +91,7 @@ class TestProcessorDefault < SexpProcessor # ZenTest SKIP
     self.default_method = :def_method
   end
 
-  def def_method(exp)
+  def def_method exp
     exp.clear
     self.expected.new(42)
   end
@@ -98,13 +106,13 @@ class TestSexpProcessor < Minitest::Test
   end
 
   def test_process_specific
-    a = [:specific, [:x, 1], [:y, 2], [:z, 3]]
-    expected = [:blah, [:x, 1], [:y, 2], [:z, 3]]
+    a = s(:specific, s(:x, 1), s(:y, 2), s(:z, 3))
+    expected = s(:blah, s(:x, 1), s(:y, 2), s(:z, 3))
     assert_equal(expected, @processor.process(a))
   end
 
   def test_process_generic
-    a = [:blah, 1, 2, 3]
+    a = s(:blah, 1, 2, 3)
     expected = a.deep_clone
     assert_equal(expected, @processor.process(a))
   end
@@ -122,7 +130,7 @@ class TestSexpProcessor < Minitest::Test
     @processor.warn_on_default = false
 
     assert_raises SexpTypeError do
-      @processor.process([:broken, 1, 2, 3])
+      @processor.process(s(:broken, 1, 2, 3))
     end
   end
 
@@ -131,7 +139,7 @@ class TestSexpProcessor < Minitest::Test
     @processor.unsupported << :strip
 
     assert_raises UnsupportedNodeError do
-      @processor.process([:whatever])
+      @processor.process(s(:whatever))
     end
   end
 
@@ -139,29 +147,32 @@ class TestSexpProcessor < Minitest::Test
     @processor.strict = true
     @processor.unsupported = [ :unsupported ]
     assert_raises UnsupportedNodeError do
-      @processor.process([:unsupported, 42])
+      @processor.process(s(:unsupported, 42))
     end
   end
 
   def test_strict
     @processor.strict = true
     assert_raises UnknownNodeError do
-      @processor.process([:blah, 1, 2, 3])
+      @processor.process(s(:blah, 1, 2, 3))
     end
   end
-  def test_strict=; skip; end #Handled
+
+  def test_strict=; skip; end # handled
 
   def test_require_empty_false
     @processor.require_empty = false
 
-    assert_equal s(:nonempty, 1, 2, 3), @processor.process([:nonempty, 1, 2, 3])
+    assert_equal s(:nonempty, 1, 2, 3), @processor.process(s(:nonempty, 1, 2, 3))
   end
 
   def test_require_empty_true
     assert_raises NotEmptyError do
-      @processor.process([:nonempty, 1, 2, 3])
+      @processor.require_empty = true
+      @processor.process(s(:nonempty, 1, 2, 3))
     end
   end
+
   def test_require_empty=; skip; end # handled
 
   def test_process_strip
@@ -189,7 +200,6 @@ class TestSexpProcessor < Minitest::Test
     expect = s(:rewritable, 2, 1)
     result = @processor.rewrite(insert)
     assert_equal(expect, result)
-    assert_equal(s(2), insert) # post-processing
   end
 
   def test_process_rewrite
@@ -256,6 +266,7 @@ class TestSexpProcessor < Minitest::Test
     @processor.auto_shift_type = true
     assert_equal(true, @processor.auto_shift_type)
   end
+
   def test_auto_shift_type_equal; skip; end # handled
 
   def test_default_method
@@ -264,12 +275,13 @@ class TestSexpProcessor < Minitest::Test
     @processor.default_method = :something
     assert_equal :something, @processor.default_method
   end
+
   def test_default_method=; skip; end # handled
 
   def test_expected
     assert_equal Sexp, @processor.expected
     assert_raises SexpTypeError do
-      @processor.process([:expected])           # should raise
+      @processor.process(s(:expected))           # should raise
     end
 
     @processor.process(s(:str, "string"))       # shouldn't raise
@@ -282,8 +294,9 @@ class TestSexpProcessor < Minitest::Test
       @processor.process(s(:string, "string"))     # should raise
     end
 
-    @processor.process([:expected])        # shouldn't raise
+    @processor.process(s(:expected))        # shouldn't raise
   end
+
   def test_expected=; skip; end # handled
 
   # Not Testing:
@@ -323,7 +336,7 @@ class TestMethodBasedSexpProcessor < Minitest::Test
 
     assert_empty processor.method_stack
 
-    expected = {"main#xxx" => "file.rb:42"}
+    expected = { "main#xxx" => "file.rb:42" }
     assert_equal expected, processor.method_locations
   end
 
@@ -336,7 +349,7 @@ class TestMethodBasedSexpProcessor < Minitest::Test
 
     assert_empty processor.method_stack
 
-    expected = {"main#xxx" => "file.rb:42-44"}
+    expected = { "main#xxx" => "file.rb:42-44" }
     assert_equal expected, processor.method_locations
   end
 

data/bundle/ruby/2.3.0/gems/{tilt-2.0.7 → tilt-2.0.8}/CHANGELOG.md

@@ -1,3 +1,13 @@
+## master
+
+## 2.0.8 (2017-07-24)
+
+* Register .tsx for TypeScript (#315, backus)
+* Use Haml 5's new API (#312, k0kubun)
+* Use correct parser options for CommonMarker (#320, rewritten)
+* Suppress warnings when no locals are used (#304, amatsuda)
+* Haml: Accept `outvar` (#317, k0kubun)
+
 ## 2.0.7 (2017-03-19)
 
 * Do not modify BasicObject during template compilation on ruby 2.0+ (#309, jeremyevans)

data/bundle/ruby/2.3.0/gems/{tilt-2.0.7 → tilt-2.0.8}/Gemfile

@@ -1,5 +1,7 @@
 source 'https://rubygems.org'
 
+gemspec
+
 gem 'rake'
 gem 'minitest', '~> 5.0'
 
@@ -12,7 +14,7 @@ can_execjs = (RUBY_VERSION >= '1.9.3')
 
 group :primary do
   gem 'builder'
-  gem 'haml', '>= 2.2.11', '< 4'
+  gem 'haml', '>= 4' if RUBY_VERSION >= '2.0.0'
   gem 'erubis'
   gem 'markaby'
   gem 'sass'
@@ -61,7 +63,3 @@ group :secondary do
   end
 end
 
-## WHY do I have to do this?!?
-platform :rbx do
-  gem 'rubysl'
-end

data/bundle/ruby/2.3.0/gems/{tilt-2.0.7 → tilt-2.0.8}/lib/tilt.rb

@@ -4,7 +4,7 @@ require 'tilt/template'
 # Namespace for Tilt. This module is not intended to be included anywhere.
 module Tilt
   # Current version.
-  VERSION = '2.0.7'
+  VERSION = '2.0.8'
 
   @default_mapping = Mapping.new
 
@@ -153,7 +153,7 @@ module Tilt
   register_lazy :ScssTemplate,         'tilt/sass',      'scss'
   register_lazy :SigilTemplate,        'tilt/sigil',     'sigil'
   register_lazy :StringTemplate,       'tilt/string',    'str'
-  register_lazy :TypeScriptTemplate,   'tilt/typescript', 'ts'
+  register_lazy :TypeScriptTemplate,   'tilt/typescript', 'ts', 'tsx'
   register_lazy :WikiClothTemplate,    'tilt/wikicloth', 'wiki', 'mediawiki', 'mw'
   register_lazy :YajlTemplate,         'tilt/yajl',      'yajl'
 

data/bundle/ruby/2.3.0/gems/{tilt-2.0.7 → tilt-2.0.8}/lib/tilt/commonmarker.rb

@@ -11,7 +11,7 @@ module Tilt
     end
 
     def evaluate(scope, locals, &block)
-      CommonMarker.render_html(data, :default)
+      CommonMarker.render_html(data, :DEFAULT)
     end
 
     def allows_script?

data/bundle/ruby/2.3.0/gems/tilt-2.0.8/lib/tilt/haml.rb

@@ -0,0 +1,86 @@
+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