brakeman 3.2.1 → 3.3.0

data/bundle/ruby/2.3.0/gems/tilt-2.0.2/test/tilt_mapping_test.rb

@@ -0,0 +1,229 @@
+require 'test_helper'
+require 'tilt'
+require 'tilt/mapping'
+
+module Tilt
+
+  class MappingTest < Minitest::Test
+    class Stub
+    end
+
+    class Stub2
+    end
+
+    setup do
+      @mapping = Mapping.new
+    end
+
+    test "registered?" do
+      @mapping.register(Stub, 'foo', 'bar')
+      assert @mapping.registered?('foo')
+      assert @mapping.registered?('bar')
+      refute @mapping.registered?('baz')
+    end
+
+    test "lookups on registered" do
+      @mapping.register(Stub, 'foo', 'bar')
+      assert_equal Stub, @mapping['foo']
+      assert_equal Stub, @mapping['bar']
+      assert_equal Stub, @mapping['hello.foo']
+      assert_nil @mapping['foo.baz']
+    end
+
+    test "can be dup'd" do
+      @mapping.register(Stub, 'foo')
+      other = @mapping.dup
+      assert other.registered?('foo')
+
+      # @mapping doesn't leak to other
+      @mapping.register(Stub, 'bar')
+      refute other.registered?('bar')
+
+      # other doesn't leak to @mapping
+      other.register(Stub, 'baz')
+      refute @mapping.registered?('baz')
+    end
+
+    test "#extensions_for" do
+      @mapping.register(Stub, 'foo', 'bar')
+      assert_equal ['foo', 'bar'].sort, @mapping.extensions_for(Stub).sort
+    end
+
+    test "supports old-style #register" do
+      @mapping.register('foo', Stub)
+      assert_equal Stub, @mapping['foo']
+    end
+
+    context "lazy with one template class" do
+      setup do
+        @mapping.register_lazy('MyTemplate', 'my_template', 'mt')
+      end
+
+      teardown do
+        Object.send :remove_const, :MyTemplate if defined? ::MyTemplate
+      end
+
+      test "registered?" do
+        assert @mapping.registered?('mt')
+      end
+
+      test "#extensions_for" do
+        assert_equal ['mt'], @mapping.extensions_for('MyTemplate')
+      end
+
+      test "basic lookup" do
+        req = proc do |file|
+          assert_equal 'my_template', file
+          class ::MyTemplate; end
+          true
+        end
+
+        @mapping.stub :require, req do
+          klass = @mapping['hello.mt']
+          assert_equal ::MyTemplate, klass
+        end
+      end
+
+      test "doesn't require when template class is present" do
+        class ::MyTemplate; end
+
+        req = proc do |file|
+          flunk "#require shouldn't be called"
+        end
+
+        @mapping.stub :require, req do
+          klass = @mapping['hello.mt']
+          assert_equal ::MyTemplate, klass
+        end
+      end
+
+      test "raises NameError when the class name is defined" do
+        req = proc do |file|
+          # do nothing
+        end
+
+        @mapping.stub :require, req do
+          assert_raises(NameError) do
+            @mapping['hello.mt']
+          end
+        end
+      end
+
+      test "warns when there's multiple threads" do
+        Thread.new do
+          req = proc do |file|
+            class ::MyTemplate; end
+          end
+
+          @mapping.stub :require, req do
+            assert_output '', /autoloading 'my_template'/ do
+              @mapping['hello.mt']
+            end
+          end
+        end.join
+      end
+    end
+
+    context "lazy with two template classes" do
+      setup do
+        @mapping.register_lazy('MyTemplate1', 'my_template1', 'mt')
+        @mapping.register_lazy('MyTemplate2', 'my_template2', 'mt')
+      end
+
+      teardown do
+        Object.send :remove_const, :MyTemplate1 if defined? ::MyTemplate1
+        Object.send :remove_const, :MyTemplate2 if defined? ::MyTemplate2
+      end
+
+      test "registered?" do
+        assert @mapping.registered?('mt')
+      end
+
+      test "only attempt to load the last template" do
+        req = proc do |file|
+          assert_equal 'my_template2', file
+          class ::MyTemplate2; end
+          true
+        end
+
+        @mapping.stub :require, req do
+          klass = @mapping['hello.mt']
+          assert_equal ::MyTemplate2, klass
+        end
+      end
+
+      test "uses the first template if it's present" do
+        class ::MyTemplate1; end
+
+        req = proc do |file|
+          flunk
+        end
+
+        @mapping.stub :require, req do
+          klass = @mapping['hello.mt']
+          assert_equal ::MyTemplate1, klass
+        end
+      end
+
+      test "falls back when LoadError is thrown" do
+        req = proc do |file|
+          raise LoadError unless file == 'my_template1'
+          class ::MyTemplate1; end
+          true
+        end
+
+        @mapping.stub :require, req do
+          klass = @mapping['hello.mt']
+          assert_equal ::MyTemplate1, klass
+        end
+      end
+
+      test "raises the first LoadError when everything fails" do
+        req = proc do |file|
+          raise LoadError, file
+        end
+
+        @mapping.stub :require, req do
+          err = assert_raises(LoadError) do
+            klass = @mapping['hello.mt']
+          end
+
+          assert_equal 'my_template2', err.message
+        end
+      end
+
+      test "handles autoloaded constants" do
+        Object.autoload :MyTemplate2, 'my_template2'
+        class ::MyTemplate1; end
+
+        assert_equal MyTemplate1, @mapping['hello.mt']
+      end
+    end
+
+    test "raises NameError on invalid class name" do
+      @mapping.register_lazy '#foo', 'my_template', 'mt'
+
+      req = proc do |file|
+        # do nothing
+      end
+
+      @mapping.stub :require, req do
+        assert_raises(NameError) do
+          @mapping['hello.mt']
+        end
+      end
+    end
+
+    context "#templates_for" do
+      setup do
+        @mapping.register Stub, 'a'
+        @mapping.register Stub2, 'b'
+      end
+
+      test "handles multiple engines" do
+        assert_equal [Stub2, Stub], @mapping.templates_for('hello/world.a.b')
+      end
+    end
+  end
+end
+

data/bundle/ruby/2.3.0/gems/tilt-2.0.2/test/tilt_markaby_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+require 'tilt'
+
+begin
+  require 'tilt/markaby'
+
+  class MarkabyTiltTest <  Minitest::Test
+    def setup
+      @block = lambda do |t|
+        File.read(File.dirname(__FILE__) + "/#{t.file}")
+      end
+    end
+
+    test "should be able to render a markaby template with static html" do
+      tilt = Tilt::MarkabyTemplate.new("markaby/markaby.mab", &@block)
+      assert_equal "hello from markaby!", tilt.render
+    end
+
+    test "should use the contents of the template" do
+      tilt = ::Tilt::MarkabyTemplate.new("markaby/markaby_other_static.mab", &@block)
+      assert_equal "_why?", tilt.render
+    end
+
+    test "should render from a string (given as data)" do
+      tilt = ::Tilt::MarkabyTemplate.new { "html do; end" }
+      assert_equal "<html></html>", tilt.render
+    end
+
+    test "can be rendered more than once" do
+      tilt = ::Tilt::MarkabyTemplate.new { "html do; end" }
+      3.times { assert_equal "<html></html>", tilt.render }
+    end
+
+    test "should evaluate a template file in the scope given" do
+      scope = Object.new
+      def scope.foo
+        "bar"
+      end
+
+      tilt = ::Tilt::MarkabyTemplate.new("markaby/scope.mab", &@block)
+      assert_equal "<li>bar</li>", tilt.render(scope)
+    end
+
+    test "should pass locals to the template" do
+      tilt = ::Tilt::MarkabyTemplate.new("markaby/locals.mab", &@block)
+      assert_equal "<li>bar</li>", tilt.render(Object.new, { :foo => "bar" })
+    end
+
+    test "should yield to the block given" do
+      tilt = ::Tilt::MarkabyTemplate.new("markaby/yielding.mab", &@block)
+      eval_scope = Markaby::Builder.new
+
+      output = tilt.render(Object.new, {}) do
+        text("Joe")
+      end
+
+      assert_equal "Hey Joe", output
+    end
+
+    test "should be able to render two templates in a row" do
+      tilt = ::Tilt::MarkabyTemplate.new("markaby/render_twice.mab", &@block)
+
+      assert_equal "foo", tilt.render
+      assert_equal "foo", tilt.render
+    end
+
+    test "should retrieve a Tilt::MarkabyTemplate when calling Tilt['hello.mab']" do
+      assert_equal Tilt::MarkabyTemplate, ::Tilt['./markaby/markaby.mab']
+    end
+
+    test "should return a new instance of the implementation class (when calling Tilt.new)" do
+      assert ::Tilt.new(File.dirname(__FILE__) + "/markaby/markaby.mab").kind_of?(Tilt::MarkabyTemplate)
+    end
+
+    test "should be able to evaluate block style templates" do
+      tilt = Tilt::MarkabyTemplate.new { |t| lambda { h1 "Hello World!" }}
+      assert_equal "<h1>Hello World!</h1>", tilt.render
+    end
+
+    test "should pass locals to block style templates" do
+      tilt = Tilt::MarkabyTemplate.new { |t| lambda { h1 "Hello #{name}!" }}
+      assert_equal "<h1>Hello _why!</h1>", tilt.render(nil, :name => "_why")
+    end
+  end
+
+rescue LoadError => boom
+  warn "Tilt::MarkabyTemplate (disabled)"
+end

data/bundle/ruby/2.3.0/gems/tilt-2.0.2/test/tilt_markdown_test.rb

@@ -0,0 +1,177 @@
+# coding: UTF-8
+require 'tilt'
+require 'test_helper'
+
+begin
+require 'nokogiri'
+
+module MarkdownTests
+  def self.included(mod)
+    class << mod
+      def template(t = nil)
+        t.nil? ? @template : @template = t
+      end
+    end
+  end
+
+  def render(text, options = {})
+    self.class.template.new(options) { text }.render
+  end
+
+  def normalize(html)
+    Nokogiri::HTML.fragment(html).to_s.strip
+  end
+
+  def nrender(text, options = {})
+    html = render(text, options)
+    html.encode!("UTF-8") if html.respond_to?(:encode)
+    normalize(html)
+  end
+
+  def test_escape_html
+    html = nrender "Hello <b>World</b>"
+    assert_equal "<p>Hello <b>World</b></p>", html
+  end
+
+  def test_escape_html_false
+    html = nrender "Hello <b>World</b>", :escape_html => false
+    assert_equal "<p>Hello <b>World</b></p>", html
+  end
+
+  def test_escape_html_true
+    html = nrender "Hello <b>World</b>", :escape_html => true
+    assert_equal "<p>Hello &lt;b&gt;World&lt;/b&gt;</p>", html
+  end
+
+  def test_smart_quotes
+    html = nrender 'Hello "World"'
+    assert_equal '<p>Hello "World"</p>', html
+  end
+
+  def test_smart_quotes_false
+    html = nrender 'Hello "World"', :smartypants => false
+    assert_equal '<p>Hello "World"</p>', html
+  end
+
+  def test_smart_quotes_true
+    html = nrender 'Hello "World"', :smartypants => true
+    assert_equal '<p>Hello “World”</p>', html
+  end
+
+  def test_smarty_pants
+    html = nrender "Hello ``World'' -- This is --- a test ..."
+    assert_equal "<p>Hello ``World'' -- This is --- a test ...</p>", html
+  end
+
+  def test_smarty_pants_false
+    html = nrender "Hello ``World'' -- This is --- a test ...", :smartypants => false
+    assert_equal "<p>Hello ``World'' -- This is --- a test ...</p>", html
+  end
+end
+
+begin
+  require 'tilt/rdiscount'
+
+  class MarkdownRDiscountTest < Minitest::Test
+    include MarkdownTests
+    template Tilt::RDiscountTemplate
+
+    def test_smarty_pants_true
+      html = nrender "Hello ``World'' -- This is --- a test ...", :smartypants => true
+      assert_equal "<p>Hello “World” – This is — a test …</p>", html
+    end
+  end
+rescue LoadError => boom
+  # It should already be warned in the main tests
+end
+
+begin
+  require 'tilt/redcarpet'
+
+  class MarkdownRedcarpetTest < Minitest::Test
+    include MarkdownTests
+    template Tilt::RedcarpetTemplate
+
+    def test_smarty_pants_true
+      # Various versions of Redcarpet support various versions of Smart pants.
+      html = nrender "Hello ``World'' -- This is --- a test ...", :smartypants => true
+      assert_match /<p>Hello “World(''|”) – This is — a test …<\/p>/, html
+    end
+
+    def test_renderer_options
+      html = nrender "Hello [World](http://example.com)", :smartypants => true, :no_links => true
+      assert_equal "<p>Hello [World](http://example.com)</p>", html
+    end
+
+    def test_fenced_code_blocks_with_lang
+      code = <<-COD.gsub(/^\s+/,"")
+      ```ruby
+      puts "hello world"
+      ```
+      COD
+
+      html = nrender code, :fenced_code_blocks => true
+      assert_equal %Q{<pre><code class="ruby">puts "hello world"\n</code></pre>}, html
+    end
+  end
+rescue LoadError => boom
+  # It should already be warned in the main tests
+end
+
+begin
+  require 'tilt/bluecloth'
+
+  class MarkdownBlueClothTest < Minitest::Test
+    include MarkdownTests
+    template Tilt::BlueClothTemplate
+
+    def test_smarty_pants_true
+      html = nrender "Hello ``World'' -- This is --- a test ...", :smartypants => true
+      assert_equal "<p>Hello “World” — This is —– a test …</p>", html
+    end
+  end
+rescue LoadError => boom
+  # It should already be warned in the main tests
+end
+
+begin
+  require 'tilt/kramdown'
+
+  class MarkdownKramdownTest < Minitest::Test
+    include MarkdownTests
+    template Tilt::KramdownTemplate
+    # Doesn't support escaping
+    undef test_escape_html_true
+    # Smarty Pants is *always* on, but doesn't support it fully
+    undef test_smarty_pants
+    undef test_smarty_pants_false
+  end
+rescue LoadError => boom
+  # It should already be warned in the main tests
+end
+
+
+begin
+  require 'tilt/maruku'
+
+  class MarkdownMarukuTest < Minitest::Test
+    include MarkdownTests
+    template Tilt::MarukuTemplate
+    # Doesn't support escaping
+    undef test_escape_html_true
+    # Doesn't support Smarty Pants, and even fails on ``Foobar''
+    undef test_smarty_pants
+    undef test_smarty_pants_false
+    # Smart Quotes is always on
+    undef test_smart_quotes
+    undef test_smart_quotes_false
+  end
+rescue LoadError => boom
+  # It should already be warned in the main tests
+end
+
+rescue LoadError
+  warn "Markdown tests need Nokogiri"
+end
+
+