brakeman 3.2.1 → 3.3.0

data/bundle/ruby/2.3.0/gems/temple-0.7.6/test/html/test_attribute_merger.rb

@@ -0,0 +1,76 @@
+require 'helper'
+
+describe Temple::HTML::AttributeMerger do
+  before do
+    @merger = Temple::HTML::AttributeMerger.new
+  end
+
+  it 'should pass static attributes through' do
+    @merger.call([:html, :tag,
+      'div',
+      [:html, :attrs, [:html, :attr, 'class', [:static, 'b']]],
+      [:content]
+    ]).should.equal [:html, :tag, "div",
+                     [:html, :attrs,
+                      [:html, :attr, "class", [:static, "b"]]],
+                     [:content]]
+  end
+
+  it 'should preserve the order of html attributes' do
+    @merger.call([:html, :tag,
+      'meta',
+      [:html, :attrs, [:html, :attr, 'c', [:static, '1']],
+                      [:html, :attr, 'd', [:static, '2']],
+                      [:html, :attr, 'a', [:static, '3']],
+                      [:html, :attr, 'b', [:static, '4']]]
+    ]).should.equal [:html, :tag, 'meta',
+                     [:html, :attrs,
+                      [:html, :attr, 'c', [:static, '1']],
+                      [:html, :attr, 'd', [:static, '2']],
+                      [:html, :attr, 'a', [:static, '3']],
+                      [:html, :attr, 'b', [:static, '4']]]]
+
+    # Use case:
+    @merger.call([:html, :tag,
+      'meta',
+      [:html, :attrs, [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
+                      [:html, :attr, 'content', [:static, '']]]
+    ]).should.equal [:html, :tag, 'meta',
+                     [:html, :attrs,
+                      [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
+                      [:html, :attr, 'content', [:static, '']]]]
+  end
+
+  it 'should merge ids' do
+    @merger.call([:html, :tag,
+      'div',
+      [:html, :attrs, [:html, :attr, 'id', [:dynamic, 'a']], [:html, :attr, 'id', [:dynamic, 'b']]],
+      [:content]
+    ]).should.equal [:html, :tag, "div",
+                     [:html, :attrs,
+                      [:html, :attr, "id",
+                       [:multi,
+                        [:code, "_temple_html_attributemerger1 = []"],
+                        [:capture, "_temple_html_attributemerger1[0]", [:dynamic, "a"]],
+                        [:capture, "_temple_html_attributemerger1[1]", [:dynamic, "b"]],
+                        [:dynamic, "_temple_html_attributemerger1.reject(&:empty?).join(\"_\")"]]]],
+                     [:content]]
+  end
+
+  it 'should merge classes' do
+    @merger.call([:html, :tag,
+      'div',
+      [:html, :attrs, [:html, :attr, 'class', [:static, 'a']], [:html, :attr, 'class', [:dynamic, 'b']]],
+      [:content]
+    ]).should.equal [:html, :tag, "div",
+                     [:html, :attrs,
+                      [:html, :attr, "class",
+                       [:multi,
+                        [:code, "_temple_html_attributemerger1 = []"],
+                        [:capture, "_temple_html_attributemerger1[0]", [:static, "a"]],
+                        [:capture, "_temple_html_attributemerger1[1]", [:dynamic, "b"]],
+                        [:dynamic, "_temple_html_attributemerger1.reject(&:empty?).join(\" \")"]]]],
+                     [:content]]
+  end
+end
+

data/bundle/ruby/2.3.0/gems/temple-0.7.6/test/html/test_attribute_remover.rb

@@ -0,0 +1,43 @@
+require 'helper'
+
+describe Temple::HTML::AttributeRemover do
+  before do
+    @remover = Temple::HTML::AttributeRemover.new
+  end
+
+  it 'should pass static attributes through' do
+    @remover.call([:html, :tag,
+      'div',
+      [:html, :attrs, [:html, :attr, 'class', [:static, 'b']]],
+      [:content]
+    ]).should.equal [:html, :tag, "div",
+                     [:multi,
+                      [:html, :attr, "class", [:static, "b"]]],
+                     [:content]]
+  end
+
+  it 'should check for empty dynamic attribute if it is included in :remove_empty_attrs' do
+    @remover.call([:html, :tag,
+      'div',
+      [:html, :attrs, [:html, :attr, 'class', [:dynamic, 'b']]],
+      [:content]
+    ]).should.equal [:html, :tag, "div",
+                    [:multi,
+                      [:multi,
+                       [:capture, "_temple_html_attributeremover1", [:dynamic, "b"]],
+                       [:if, "!_temple_html_attributeremover1.empty?",
+                        [:html, :attr, "class", [:dynamic, "_temple_html_attributeremover1"]]]]],
+                     [:content]]
+  end
+
+  it 'should not check for empty dynamic attribute if it is not included in :remove_empty_attrs' do
+    @remover.call([:html, :tag,
+      'div',
+      [:html, :attrs, [:html, :attr, 'name', [:dynamic, 'b']]],
+      [:content]
+    ]).should.equal [:html, :tag, "div",
+                     [:multi,
+                      [:html, :attr, "name", [:dynamic, "b"]]],
+                     [:content]]
+  end
+end

data/bundle/ruby/2.3.0/gems/temple-0.7.6/test/html/test_attribute_sorter.rb

@@ -0,0 +1,48 @@
+require 'helper'
+
+describe Temple::HTML::AttributeSorter do
+  before do
+    @ordered   = Temple::HTML::AttributeSorter.new
+    @unordered = Temple::HTML::AttributeSorter.new sort_attrs: false
+  end
+
+  it 'should sort html attributes by name by default, when :sort_attrs is true' do
+    @ordered.call([:html, :tag,
+      'meta',
+      [:html, :attrs, [:html, :attr, 'c', [:static, '1']],
+                      [:html, :attr, 'd', [:static, '2']],
+                      [:html, :attr, 'a', [:static, '3']],
+                      [:html, :attr, 'b', [:static, '4']]]
+    ]).should.equal [:html, :tag, 'meta',
+                     [:html, :attrs,
+                      [:html, :attr, 'a', [:static, '3']],
+                      [:html, :attr, 'b', [:static, '4']],
+                      [:html, :attr, 'c', [:static, '1']],
+                      [:html, :attr, 'd', [:static, '2']]]]
+  end
+
+  it 'should preserve the order of html attributes when :sort_attrs is false' do
+    @unordered.call([:html, :tag,
+      'meta',
+      [:html, :attrs, [:html, :attr, 'c', [:static, '1']],
+                      [:html, :attr, 'd', [:static, '2']],
+                      [:html, :attr, 'a', [:static, '3']],
+                      [:html, :attr, 'b', [:static, '4']]]
+    ]).should.equal [:html, :tag, 'meta',
+                     [:html, :attrs,
+                      [:html, :attr, 'c', [:static, '1']],
+                      [:html, :attr, 'd', [:static, '2']],
+                      [:html, :attr, 'a', [:static, '3']],
+                      [:html, :attr, 'b', [:static, '4']]]]
+
+    # Use case:
+    @unordered.call([:html, :tag,
+      'meta',
+      [:html, :attrs, [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
+                      [:html, :attr, 'content', [:static, '']]]
+    ]).should.equal [:html, :tag, 'meta',
+                     [:html, :attrs,
+                      [:html, :attr, 'http-equiv', [:static, 'Content-Type']],
+                      [:html, :attr, 'content', [:static, '']]]]
+  end
+end

data/bundle/ruby/2.3.0/gems/temple-0.7.6/test/html/test_fast.rb

@@ -0,0 +1,97 @@
+require 'helper'
+
+describe Temple::HTML::Fast do
+  before do
+    @html = Temple::HTML::Fast.new
+  end
+
+  it 'should compile html doctype' do
+    @html.call([:multi, [:html, :doctype, '5']]).should.equal [:multi, [:static, '<!DOCTYPE html>']]
+    @html.call([:multi, [:html, :doctype, 'html']]).should.equal [:multi, [:static, '<!DOCTYPE html>']]
+    @html.call([:multi, [:html, :doctype, '1.1']]).should.equal [:multi,
+      [:static, '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">']]
+  end
+
+  it 'should compile xml encoding' do
+    @html.call([:html, :doctype, 'xml latin1']).should.equal [:static, "<?xml version=\"1.0\" encoding=\"latin1\" ?>"]
+  end
+
+  it 'should compile html comment' do
+    @html.call([:html, :comment, [:static, 'test']]).should.equal [:multi, [:static, "<!--"], [:static, "test"], [:static, "-->"]]
+  end
+
+  it 'should compile js wrapped in comments' do
+    Temple::HTML::Fast.new(js_wrapper: nil).call([:html, :js, [:static, 'test']]).should.equal [:static, "test"]
+    Temple::HTML::Fast.new(js_wrapper: :comment).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]]
+    Temple::HTML::Fast.new(js_wrapper: :cdata).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]]
+    Temple::HTML::Fast.new(js_wrapper: :both).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n//-->"]]
+  end
+
+  it 'should guess default js comment' do
+    Temple::HTML::Fast.new(js_wrapper: :guess, format: :xhtml).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]]
+    Temple::HTML::Fast.new(js_wrapper: :guess, format: :html).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]]
+  end
+
+  it 'should compile autoclosed html tag' do
+    @html.call([:html, :tag,
+      'img', [:attrs],
+      [:multi, [:newline]]
+    ]).should.equal [:multi,
+                     [:static, "<img"],
+                     [:attrs],
+                     [:static, " />"],
+                     [:multi, [:newline]]]
+  end
+
+  it 'should compile explicitly closed html tag' do
+    @html.call([:html, :tag,
+      'closed', [:attrs]
+    ]).should.equal [:multi,
+                     [:static, "<closed"],
+                     [:attrs],
+                     [:static, " />"]]
+  end
+
+  it 'should compile html with content' do
+    @html.call([:html, :tag,
+      'div', [:attrs], [:content]
+    ]).should.equal [:multi,
+                     [:static, "<div"],
+                     [:attrs],
+                     [:static, ">"],
+                     [:content],
+                     [:static, "</div>"]]
+  end
+
+  it 'should compile html with attrs' do
+    @html.call([:html, :tag,
+      'div',
+      [:html, :attrs,
+       [:html, :attr, 'id', [:static, 'test']],
+       [:html, :attr, 'class', [:dynamic, 'block']]],
+       [:content]
+    ]).should.equal [:multi,
+                     [:static, "<div"],
+                     [:multi,
+                      [:multi, [:static, " id=\""], [:static, "test"], [:static, '"']],
+                      [:multi, [:static, " class=\""], [:dynamic, "block"], [:static, '"']]],
+                     [:static, ">"],
+                     [:content],
+                     [:static, "</div>"]]
+  end
+
+  it 'should keep codes intact' do
+    exp = [:multi, [:code, 'foo']]
+    @html.call(exp).should.equal exp
+  end
+
+  it 'should keep statics intact' do
+    exp = [:multi, [:static, '<']]
+    @html.call(exp).should.equal exp
+  end
+
+  it 'should keep dynamic intact' do
+    exp = [:multi, [:dynamic, 'foo']]
+    @html.call(exp).should.equal exp
+  end
+end

data/bundle/ruby/2.3.0/gems/temple-0.7.6/test/html/test_pretty.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+describe Temple::HTML::Pretty do
+  before do
+    @html = Temple::HTML::Pretty.new
+  end
+
+  it 'should indent nested tags' do
+    @html.call([:html, :tag, 'div', [:multi],
+      [:html, :tag, 'p', [:multi], [:multi, [:static, 'text'], [:dynamic, 'code']]]
+    ]).should.equal [:multi,
+                     [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
+                     [:multi,
+                      [:static, "<div"],
+                      [:multi],
+                      [:static, ">"],
+                      [:multi,
+                       [:static, "\n  <p"],
+                       [:multi],
+                       [:static, ">"],
+                       [:multi,
+                        [:static, "\n    text"],
+                        [:dynamic, "::Temple::Utils.indent_dynamic((code), false, \"\\n    \", _temple_html_pretty1)"]],
+                       [:static, "\n  </p>"]],
+                      [:static, "\n</div>"]]]
+  end
+
+  it 'should not indent preformatted tags' do
+    @html.call([:html, :tag, 'pre', [:multi],
+      [:html, :tag, 'p', [:multi], [:static, 'text']]
+    ]).should.equal [:multi,
+                     [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
+                     [:multi,
+                      [:static, "<pre"],
+                      [:multi],
+                      [:static, ">"],
+                      [:multi,
+                       [:static, "<p"],
+                       [:multi],
+                       [:static, ">"],
+                       [:static, "text"],
+                       [:static, "</p>"]],
+                      [:static, "</pre>"]]]
+  end
+
+  it 'should not escape html_safe strings' do
+    with_html_safe do
+      @html.call(
+        [:dynamic, '"text<".html_safe']
+      ).should.equal [:multi,
+                      [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
+                      [:dynamic, "::Temple::Utils.indent_dynamic((\"text<\".html_safe), nil, \"\\n\", _temple_html_pretty1)"]]
+    end
+  end
+end

data/bundle/ruby/2.3.0/gems/temple-0.7.6/test/mixins/test_dispatcher.rb

@@ -0,0 +1,70 @@
+require 'helper'
+
+class FilterWithDispatcherMixin
+  include Temple::Mixins::Dispatcher
+
+  def on_test(arg)
+    [:on_test, arg]
+  end
+
+  def on_test_check(arg)
+    [:on_check, arg]
+  end
+
+  def on_second_test(arg)
+    [:on_second_test, arg]
+  end
+
+  def on_a_b(*arg)
+    [:on_ab, *arg]
+  end
+
+  def on_a_b_test(arg)
+    [:on_ab_test, arg]
+  end
+
+  def on_a_b_c_d_test(arg)
+    [:on_abcd_test, arg]
+  end
+end
+
+class FilterWithDispatcherMixinAndOn < FilterWithDispatcherMixin
+  def on(*args)
+    [:on_zero, *args]
+  end
+end
+
+describe Temple::Mixins::Dispatcher do
+  before do
+    @filter = FilterWithDispatcherMixin.new
+  end
+
+  it 'should return unhandled expressions' do
+    @filter.call([:unhandled]).should.equal [:unhandled]
+  end
+
+  it 'should dispatch first level' do
+    @filter.call([:test, 42]).should.equal [:on_test, 42]
+  end
+
+  it 'should dispatch second level' do
+    @filter.call([:second, :test, 42]).should.equal [:on_second_test, 42]
+  end
+
+  it 'should dispatch second level if prefixed' do
+    @filter.call([:test, :check, 42]).should.equal [:on_check, 42]
+  end
+
+  it 'should dispatch parent level' do
+    @filter.call([:a, 42]).should == [:a, 42]
+    @filter.call([:a, :b, 42]).should == [:on_ab, 42]
+    @filter.call([:a, :b, :test, 42]).should == [:on_ab_test, 42]
+    @filter.call([:a, :b, :c, 42]).should == [:on_ab, :c, 42]
+    @filter.call([:a, :b, :c, :d, 42]).should == [:on_ab, :c, :d, 42]
+    @filter.call([:a, :b, :c, :d, :test, 42]).should == [:on_abcd_test, 42]
+  end
+
+  it 'should dispatch zero level' do
+    FilterWithDispatcherMixinAndOn.new.call([:foo,42]).should == [:on_zero, :foo, 42]
+  end
+end

data/bundle/ruby/2.3.0/gems/temple-0.7.6/test/mixins/test_grammar_dsl.rb

@@ -0,0 +1,86 @@
+require 'helper'
+
+module BasicGrammar
+  extend Temple::Mixins::GrammarDSL
+
+  Expression <<
+    Symbol |
+    Answer |
+    [:zero_or_more, 'Expression*'] |
+    [:one_or_more,  'Expression+'] |
+    [:zero_or_one,  'Expression?'] |
+    [:bool, Bool] |
+    nil
+
+  Bool <<
+    true | false
+
+  Answer <<
+    Value(42)
+
+end
+
+module ExtendedGrammar
+  extend BasicGrammar
+
+  Expression << [:extended, Expression]
+end
+
+describe Temple::Mixins::GrammarDSL do
+  it 'should support class types' do
+    BasicGrammar.should.match :symbol
+    BasicGrammar.should.not.match [:symbol]
+    BasicGrammar.should.not.match 'string'
+    BasicGrammar.should.not.match ['string']
+  end
+
+  it 'should support value types' do
+    BasicGrammar.should.match 42
+    BasicGrammar.should.not.match 43
+  end
+
+  it 'should support nesting' do
+    BasicGrammar.should.match [:zero_or_more, [:zero_or_more]]
+  end
+
+  it 'should support *' do
+    BasicGrammar.should.match [:zero_or_more]
+    BasicGrammar.should.match [:zero_or_more, nil, 42]
+  end
+
+  it 'should support +' do
+    BasicGrammar.should.not.match [:one_or_more]
+    BasicGrammar.should.match     [:one_or_more, 42]
+    BasicGrammar.should.match     [:one_or_more, 42, nil]
+  end
+
+  it 'should support ?' do
+    BasicGrammar.should.not.match [:zero_or_one, nil, 42]
+    BasicGrammar.should.match     [:zero_or_one]
+    BasicGrammar.should.match     [:zero_or_one, 42]
+  end
+
+  it 'should support extended grammars' do
+    ExtendedGrammar.should.match [:extended, [:extended, 42]]
+    BasicGrammar.should.not.match [:zero_or_more, [:extended, nil]]
+    BasicGrammar.should.not.match [:extended, [:extended, 42]]
+  end
+
+  it 'should have validate!' do
+    grammar_validate BasicGrammar,
+                     [:zero_or_more, [:zero_or_more, [:unknown]]],
+                     "BasicGrammar::Expression did not match\n[:unknown]\n"
+
+    grammar_validate BasicGrammar,
+                     [:zero_or_more, [:one_or_more]],
+                     "BasicGrammar::Expression did not match\n[:one_or_more]\n"
+
+    grammar_validate BasicGrammar,
+                     [:zero_or_more, 123, [:unknown]],
+                     "BasicGrammar::Expression did not match\n123\n"
+
+    grammar_validate BasicGrammar,
+                     [:bool, 123],
+                     "BasicGrammar::Bool did not match\n123\n"
+  end
+end