RubyGems - brakeman - Versions diffs - 4.3.1 → 5.0.0 - Mend

brakeman 4.3.1 → 5.0.0

Files changed (1580) hide show

data/bundle/ruby/2.5.0/gems/haml-4.0.7/test/erb/_av_partial_1.erb DELETED Viewed

@@ -1,12 +0,0 @@
-<h2>This is a pretty complicated partial</h2>
-<div class="partial">
-  <p>It has several nested partials,</p>
-  <ul>
-    <% 5.times do %>
-      <li>
-        <strong>Partial:</strong>
-        <% @nesting = 5 %>
-        <%= render :partial => 'erb/av_partial_2' %>
-    <% end %>
-  </ul>
-</div>

data/bundle/ruby/2.5.0/gems/haml-4.0.7/test/erb/_av_partial_2.erb DELETED Viewed

@@ -1,8 +0,0 @@
-<% @nesting -= 1 %>
-<div class="partial" level="<%= @nesting %>">
-  <h3>This is a crazy deep-nested partial.</h3>
-  <p>Nesting level <%= @nesting %></p>
-  <% if @nesting > 0 %>
-    <%= render :partial => 'erb/av_partial_2' %>
-  <% end %>
-</div>

data/bundle/ruby/2.5.0/gems/haml-4.0.7/test/erb/action_view.erb DELETED Viewed

@@ -1,62 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en-US'>
-  <head>
-    <title>Hampton Catlin Is Totally Awesome</title>
-    <meta content='text/html; charset=utf-8' http-equiv='Content-Type' />
-  </head>
-  <body>
-    <h1>
-      This is very much like the standard template,
-      except that it has some ActionView-specific stuff.
-      It's only used for benchmarking.
-    </h1>
-    <div class="crazy_partials">
-      <%= render :partial => 'erb/av_partial_1' %>
-    </div>
-    <!-- You're In my house now! -->
-    <div class='header'>
-      Yes, ladies and gentileman. He is just that egotistical.
-      Fantastic! This should be multi-line output
-      The question is if this would translate! Ahah!
-      <%= 1 + 9 + 8 + 2 %>
-      <%# numbers should work and this should be ignored %>
-    </div>
-    <% 120.times do |number| -%>
-      <%= number %>
-    <% end -%>
-    <div id='body'><%= " Quotes should be loved! Just like people!" %></div>
-    Wow.
-    <p>
-      <%= "Holy cow        " +
-          "multiline       " +
-          "tags!           " +
-          "A pipe (|) even!"  %>
-      <%= [1, 2, 3].collect { |n| "PipesIgnored|" } %>
-      <%= [1, 2, 3].collect { |n|
-          n.to_s
-        }.join("|") %>
-    </p>
-    <div class='silent'>
-      <% foo = String.new
-         foo << "this"
-         foo << " shouldn't"
-         foo << " evaluate" %>
-      <%= foo + "but now it should!" %>
-      <%# Woah crap a comment! %>
-    </div>
-    <ul class='really cool'>
-      <% ('a'..'f').each do |a|%>
-      <li><%= a %>
-      <% end %>
-    <div class='of_divs_with_underscore' id='combo'><%= @should_eval = "with this text" %></div>
-    <%= [ 104, 101, 108, 108, 111 ].map do |byte|
-      byte.chr
-    end %>
-    <div class='footer'>
-      <strong class='shout'>
-        <%= "This is a really long ruby quote. It should be loved and wrapped because its more than 50 characters. This value may change in the future and this test may look stupid.\n" +
-"        So, I'm just making it *really* long. God, I hope this works" %>
-      </strong>
-    </div>
-  </body>
-</html>

data/bundle/ruby/2.5.0/gems/haml-4.0.7/test/erb/standard.erb DELETED Viewed

@@ -1,55 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en-US' lang='en-US'>
-  <head>
-    <title>Hampton Catlin Is Totally Awesome</title>
-    <meta content='text/html; charset=utf-8' http-equiv='Content-Type' />
-  </head>
-  <body>
-    <!-- You're In my house now! -->
-    <div class='header'>
-      Yes, ladies and gentileman. He is just that egotistical.
-      Fantastic! This should be multi-line output
-      The question is if this would translate! Ahah!
-      <%= 1 + 9 + 8 + 2 %>
-      <%# numbers should work and this should be ignored %>
-    </div>
-    <% 120.times do |number| -%>
-      <%= number %>
-    <% end -%>
-    <div id='body'><%= " Quotes should be loved! Just like people!" %></div>
-    Wow.
-    <p code="<%= 1 + 2 %>">
-      <%= "Holy cow        " +
-          "multiline       " +
-          "tags!           " +
-          "A pipe (|) even!"  %>
-      <%= [1, 2, 3].collect { |n| "PipesIgnored|" }.join %>
-      <%= [1, 2, 3].collect { |n|
-          n.to_s
-        }.join("|") %>
-    </p>
-    <% bar = 17 %>
-    <div class='silent' foo="<%= bar %>">
-      <% foo = String.new
-         foo << "this"
-         foo << " shouldn't"
-         foo << " evaluate" %>
-      <%= foo + "but now it should!" %>
-      <%# Woah crap a comment! %>
-    </div>
-    <ul class='really cool'>
-      <% ('a'..'f').each do |a|%>
-      <li><%= a %></li>
-      <% end %>
-    <div class='of_divs_with_underscore' id='combo'><%= @should_eval = "with this text" %></div>
-    <%= "foo".each_line do |line|
-      nil
-    end %>
-    <div class='footer'>
-      <strong class='shout'>
-        <%= "This is a really long ruby quote. It should be loved and wrapped because its more than 50 characters. This value may change in the future and this test may look stupid.\n" +
-"        So, I'm just making it *really* long. God, I hope this works" %>
-      </strong>
-    </div>
-  </body>
-</html>

data/bundle/ruby/2.5.0/gems/haml-4.0.7/test/filters_test.rb DELETED Viewed

@@ -1,254 +0,0 @@
-require 'test_helper'
-class FiltersTest < MiniTest::Unit::TestCase
-  test "should be registered as filters when including Haml::Filters::Base" do
-    begin
-      refute Haml::Filters.defined.has_key? "bar"
-      Module.new {def self.name; "Foo::Bar"; end; include Haml::Filters::Base}
-      assert Haml::Filters.defined.has_key? "bar"
-    ensure
-      Haml::Filters.remove_filter "Bar"
-    end
-  end
-  test "should raise error when attempting to register a defined Tilt filter" do
-    begin
-      assert_raises RuntimeError do
-        2.times do
-          Haml::Filters.register_tilt_filter "Foo"
-        end
-      end
-    ensure
-      Haml::Filters.remove_filter "Foo"
-    end
-  end
-  test "should raise error when a Tilt filters dependencies are unavailable for extension" do
-    begin
-      assert_raises Haml::Error do
-        Haml::Filters.register_tilt_filter "Textile"
-        Haml::Filters.defined["textile"].template_class
-      end
-    ensure
-      Haml::Filters.remove_filter "Textile"
-    end
-  end
-  test "should raise error when a Tilt filters dependencies are unavailable for filter without extension" do
-    begin
-      assert_raises Haml::Error do
-        Haml::Filters.register_tilt_filter "Maruku"
-        Haml::Filters.defined["maruku"].template_class
-      end
-    ensure
-      Haml::Filters.remove_filter "Maruku"
-    end
-  end
-  test "should raise informative error about Maruku being moved to haml-contrib" do
-    begin
-      render(":maruku\n  # foo")
-      flunk("Should have raised error with message about the haml-contrib gem.")
-    rescue Haml::Error => e
-      assert_equal e.message, Haml::Error.message(:install_haml_contrib, "maruku")
-    end
-  end
-  test "should raise informative error about Textile being moved to haml-contrib" do
-    begin
-      render(":textile\n  h1. foo")
-      flunk("Should have raised error with message about the haml-contrib gem.")
-    rescue Haml::Error => e
-      assert_equal e.message, Haml::Error.message(:install_haml_contrib, "textile")
-    end
-  end
-  test "should respect escaped newlines and interpolation" do
-    html = "\\n\n"
-    haml = ":plain\n  \\n\#{""}"
-    assert_equal(html, render(haml))
-  end
-  test "should process an filter with no content" do
-    assert_equal("\n", render(':plain'))
-  end
-  test "should be compatible with ugly mode" do
-    expectation = "foo\n"
-    assert_equal(expectation, render(":plain\n  foo", :ugly => true))
-  end
-  test "should pass options to Tilt filters that precompile" do
-    haml  = ":erb\n  <%= 'foo' %>"
-    refute_match('TEST_VAR', Haml::Engine.new(haml).compiler.precompiled)
-    Haml::Filters::Erb.options = {:outvar => 'TEST_VAR'}
-    assert_match('TEST_VAR', Haml::Engine.new(haml).compiler.precompiled)
-  end
-  test "should pass options to Tilt filters that don't precompile" do
-    begin
-      filter = Class.new(Tilt::Template) do
-        def self.name
-          "Foo"
-        end
-        def prepare
-          @engine = {:data => data, :options => options}
-        end
-        def evaluate(scope, locals, &block)
-          @output = @engine[:options].to_a.join
-        end
-      end
-      Haml::Filters.register_tilt_filter "Foo", :template_class => filter
-      Haml::Filters::Foo.options[:foo] = "bar"
-      haml = ":foo"
-      assert_equal "foobar\n", render(haml)
-    ensure
-      Haml::Filters.remove_filter "Foo"
-    end
-  end
-end
-class ErbFilterTest < MiniTest::Unit::TestCase
-  test "multiline expressions should work" do
-    html = "foobarbaz\n"
-    haml = %Q{:erb\n  <%= "foo" +\n      "bar" +\n      "baz" %>}
-    assert_equal(html, render(haml))
-  end
-  test "should evaluate in the same context as Haml" do
-    haml  = ":erb\n  <%= foo %>"
-    html  = "bar\n"
-    scope = Object.new.instance_eval {foo = "bar"; nil if foo; binding}
-    assert_equal(html, render(haml, :scope => scope))
-  end
-  test "should use Rails's XSS safety features" do
-    assert_equal("&lt;img&gt;\n", render(":erb\n  <%= '<img>' %>"))
-    assert_equal("<img>\n", render(":erb\n  <%= '<img>'.html_safe %>"))
-  end
-end
-class JavascriptFilterTest < MiniTest::Unit::TestCase
-  test "should interpolate" do
-    scope = Object.new.instance_eval {foo = "bar"; nil if foo; binding}
-    haml  = ":javascript\n  \#{foo}"
-    html  = render(haml, :scope => scope)
-    assert_match(/bar/, html)
-  end
-  test "should never HTML-escape ampersands" do
-    html = "<script>\n  & < > &\n</script>\n"
-    haml = %Q{:javascript\n  & < > \#{"&"}}
-    assert_equal(html, render(haml, :escape_html => true))
-  end
-  test "should not include type in HTML 5 output" do
-    html = "<script>\n  foo bar\n</script>\n"
-    haml = ":javascript\n  foo bar"
-    assert_equal(html, render(haml, :format => :html5))
-  end
-  test "should always include CDATA when format is xhtml" do
-    html = "<script type='text/javascript'>\n  //<![CDATA[\n    foo bar\n  //]]>\n</script>\n"
-    haml = ":javascript\n  foo bar"
-    assert_equal(html, render(haml, :format => :xhtml, :cdata => false))
-  end
-  test "should omit CDATA when cdata option is false" do
-    html = "<script>\n  foo bar\n</script>\n"
-    haml = ":javascript\n  foo bar"
-    assert_equal(html, render(haml, :format => :html5, :cdata => false))
-  end
-  test "should include CDATA when cdata option is true" do
-    html = "<script>\n  //<![CDATA[\n    foo bar\n  //]]>\n</script>\n"
-    haml = ":javascript\n  foo bar"
-    assert_equal(html, render(haml, :format => :html5, :cdata => true))
-  end
-  test "should default to no CDATA when format is html5" do
-    haml = ":javascript\n  foo bar"
-    out = render(haml, :format => :html5)
-    refute_match('//<![CDATA[', out)
-    refute_match('//]]>', out)
-  end
-end
-class CSSFilterTest < MiniTest::Unit::TestCase
-  test "should wrap output in CDATA and a CSS tag when output is XHTML" do
-    html = "<style type='text/css'>\n  /*<![CDATA[*/\n    foo\n  /*]]>*/\n</style>\n"
-    haml = ":css\n  foo"
-    assert_equal(html, render(haml, :format => :xhtml))
-  end
-  test "should not include type in HTML 5 output" do
-    html = "<style>\n  foo bar\n</style>\n"
-    haml = ":css\n  foo bar"
-    assert_equal(html, render(haml, :format => :html5))
-  end
-  test "should always include CDATA when format is xhtml" do
-    html = "<style type='text/css'>\n  /*<![CDATA[*/\n    foo bar\n  /*]]>*/\n</style>\n"
-    haml = ":css\n  foo bar"
-    assert_equal(html, render(haml, :format => :xhtml, :cdata => false))
-  end
-  test "should omit CDATA when cdata option is false" do
-    html = "<style>\n  foo bar\n</style>\n"
-    haml = ":css\n  foo bar"
-    assert_equal(html, render(haml, :format => :html5, :cdata => false))
-  end
-  test "should include CDATA when cdata option is true" do
-    html = "<style>\n  /*<![CDATA[*/\n    foo bar\n  /*]]>*/\n</style>\n"
-    haml = ":css\n  foo bar"
-    assert_equal(html, render(haml, :format => :html5, :cdata => true))
-  end
-  test "should default to no CDATA when format is html5" do
-    haml = ":css\n  foo bar"
-    out = render(haml, :format => :html5)
-    refute_match('<![CDATA[', out)
-    refute_match(']]>', out)
-  end
-end
-class CDATAFilterTest < MiniTest::Unit::TestCase
-  test "should wrap output in CDATA tag" do
-    html = "<![CDATA[\n    foo\n]]>\n"
-    haml = ":cdata\n  foo"
-    assert_equal(html, render(haml))
-  end
-end
-class EscapedFilterTest < MiniTest::Unit::TestCase
-  test "should escape ampersands" do
-    html = "&amp;\n"
-    haml = ":escaped\n  &"
-    assert_equal(html, render(haml))
-  end
-end
-class RubyFilterTest < MiniTest::Unit::TestCase
-  test "can write to haml_io" do
-    haml = ":ruby\n  haml_io.puts 'hello'\n"
-    html = "hello\n"
-    assert_equal(html, render(haml))
-  end
-  test "haml_io appends to output" do
-    haml = "hello\n:ruby\n  haml_io.puts 'hello'\n"
-    html = "hello\nhello\n"
-    assert_equal(html, render(haml))
-  end
-  test "can create local variables" do
-    haml = ":ruby\n  a = 7\n=a"
-    html = "7\n"
-    assert_equal(html, render(haml))
-  end
-end

data/bundle/ruby/2.5.0/gems/haml-4.0.7/test/gemfiles/Gemfile.rails-3.0.x DELETED Viewed

@@ -1,5 +0,0 @@
-source "http://rubygems.org"
-gem 'rails', '>= 3.0.0', '<  3.1.0'
-gemspec :path => "../.."

data/bundle/ruby/2.5.0/gems/haml-4.0.7/test/gemfiles/Gemfile.rails-3.1.x DELETED Viewed

@@ -1,6 +0,0 @@
-source "http://rubygems.org"
-gem 'rails', '>= 3.1.0', '< 3.2.0'
-gemspec :path => "../.."

data/bundle/ruby/2.5.0/gems/haml-4.0.7/test/gemfiles/Gemfile.rails-3.2.x DELETED Viewed

@@ -1,5 +0,0 @@
-source "http://rubygems.org"
-gem 'rails', '>= 3.2.0', '< 3.3.0'
-gemspec :path => "../.."

data/bundle/ruby/2.5.0/gems/haml-4.0.7/test/gemfiles/Gemfile.rails-4.0.x DELETED Viewed

@@ -1,5 +0,0 @@
-source "http://rubygems.org"
-gem 'bundler', '~> 1.3.0'
-gem 'rails', '~> 4.0.0.rc1'
-gemspec :path => '../..'

data/bundle/ruby/2.5.0/gems/haml-4.0.7/test/haml-spec/LICENSE DELETED Viewed

@@ -1,14 +0,0 @@
-            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-                    Version 2, December 2004
- Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
- Everyone is permitted to copy and distribute verbatim or modified
- copies of this license document, and changing it is allowed as long
- as the name is changed.
-            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-  0. You just DO WHAT THE FUCK YOU WANT TO.

data/bundle/ruby/2.5.0/gems/haml-4.0.7/test/haml-spec/README.md DELETED Viewed

@@ -1,106 +0,0 @@
-# Haml Spec #
-Haml Spec provides a basic suite of tests for Haml interpreters.
-It is intented for developers who are creating or maintaining an implementation
-of the [Haml](http://haml-lang.com) markup language.
-At the moment, there are test runners for the [original
-Haml](http://github.com/nex3/haml) in Ruby, [Lua
-Haml](http://github.com/norman/lua-haml) and the
-[Text::Haml](http://github.com/vti/text-haml) Perl port. Support for other
-versions of Haml will be added if their developers/maintainers are interested in
-using it.
-## The Tests ##
-The tests are kept in JSON format for portability across languages.  Each test
-is a JSON object with expected input, output, local variables and configuration
-parameters (see below).  The test suite only provides tests for features which
-are portable, therefore no tests for script are provided, nor for external
-filters such as :markdown or :textile.
-The one major exception to this are the tests for interpolation, which you may
-need to modify with a regular expression to run under PHP or Perl, which
-require a sigil before variable names. These tests are included despite being
-less than 100% portable because interpolation is an important part of Haml and
-can be tricky to implement. These tests are flagged as "optional" so that you
-can avoid running them if your implementation of Haml will not support this
-feature.
-## Running the Tests ##
-### Ruby ###
-The Ruby test runner uses minitest, the same as the Ruby Haml implementation.
-To run the tests you probably only need to install `haml`, `minitest` and
-possibly `ruby` if your platform doesn't come with it by default. If you're
-using Ruby 1.8.x, you'll also need to install `json`:
-    sudo gem install haml
-    sudo gem install minitest
-    # for Ruby 1.8.x; check using "ruby --version" if unsure
-    sudo gem install json
-Then, running the Ruby test suite is easy:
-    ruby ruby_haml_test.rb
-At the moment, running the tests with Ruby 1.8.7 fails because of issues with
-the JSON library. Please use 1.9.2 until this is resolved.
-### Lua ###
-The Lua test depends on
-[Penlight](http://stevedonovan.github.com/Penlight/),
-[Telescope](http://github.com/norman/telescope),
-[jason4lua](http://json.luaforge.net/), and
-[Lua Haml](http://github.com/norman/lua-haml). Install and run `tsc
-lua_haml_spec.lua`.
-### Getting it ###
-You can access the [Git repository](http://github.com/norman/haml-spec) at:
-    git://github.com/norman/haml-spec.git
-Patches are *very* welcome, as are test runners for your Haml implementation.
-As long as any test you add run against Ruby Haml and are not redundant, I'll
-be very happy to add them.
-### Test JSON format ###
-    "test name" : {
-      "haml"     : "haml input",
-      "html"     : "expected html output",
-      "result"   : "expected test result",
-      "locals"   : "local vars",
-      "config"   : "config params",
-      "optional" : true|false
-    }
-* test name: This should be a *very* brief description of what's being tested. It can
-  be used by the test runners to name test methods, or to exclude certain tests from being
-  run.
-* haml: The Haml code to be evaluated. Always required.
-* html: The HTML output that should be generated. Required unless "result" is "error".
-* result: Can be "pass" or "error". If it's absent, then "pass" is assumed. If it's "error",
-  then the goal of the test is to make sure that malformed Haml code generates an error.
-* locals: An object containing local variables needed for the test.
-* config: An object containing configuration parameters used to run the test.
-  The configuration parameters should be usable directly by Ruby's Haml with no
-  modification.  If your implementation uses config parameters with different
-  names, you may need to process them to make them match your implementation.
-  If your implementation has options that do not exist in Ruby's Haml, then you
-  should add tests for this in your implementation's test rather than here.
-* optional: whether or not the test is optional
-## License ##
-  This project is released under the [WTFPL](http://sam.zoy.org/wtfpl/) in order
-  to be as usable as possible in any project, commercial or free.
-## Author ##
-  [Norman Clarke](mailto:norman@njclarke.com)