zine_brewer 1.3.2 → 1.5.0

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/test/parser_test.rb

@@ -0,0 +1,161 @@
+require_relative 'helper'
+
+class ParserTest < Minitest::Test
+
+  def test_parser_extension
+    parser = Mustache::Parser.new
+    parser.instance_variable_set :@result, 'zomg'
+    Mustache::Parser.add_type(:'@', :'$') do |*args|
+      [:mustache, :at_sign, @result, *args]
+    end
+    assert_match Mustache::Parser.valid_types, '@'
+    assert_match Mustache::Parser.valid_types, '$'
+    assert_equal [:mustache, :at_sign, 'zomg', 1, 2, 3],
+                 parser.send('scan_tag_@', 1, 2, 3)
+    assert_equal [:mustache, :at_sign, 'zomg', 1, 2, 3],
+                 parser.send('scan_tag_$', 1, 2, 3)
+  end
+
+  def test_parser
+    lexer = Mustache::Parser.new
+    tokens = lexer.compile(<<-EOF)
+<h1>{{header}}</h1>
+{{#items}}
+{{#first}}
+  <li><strong>{{name}}</strong></li>
+{{/first}}
+{{#link}}
+  <li><a href="{{url}}">{{name}}</a></li>
+{{/link}}
+{{/items}}
+
+{{#empty}}
+<p>The list is empty.</p>
+{{/empty}}
+EOF
+
+    expected = [:multi,
+      [:static, "<h1>"],
+      [:mustache, :etag, [:mustache, :fetch, ["header"]], [1, 11]],
+      [:static, "</h1>\n"],
+      [:mustache,
+        :section,
+        [:mustache, :fetch, ["items"]],
+        [2, 7],
+        [:multi,
+          [:mustache,
+            :section,
+            [:mustache, :fetch, ["first"]],
+            [3, 7],
+            [:multi,
+              [:static, "  <li><strong>"],
+              [:mustache, :etag, [:mustache, :fetch, ["name"]], [4, 19]],
+              [:static, "</strong></li>\n"]],
+            %Q'  <li><strong>{{name}}</strong></li>\n',
+            %w[{{ }}]],
+          [:mustache,
+            :section,
+            [:mustache, :fetch, ["link"]],
+            [6, 6],
+            [:multi,
+              [:static, "  <li><a href=\""],
+              [:mustache, :etag, [:mustache, :fetch, ["url"]], [7, 19]],
+              [:static, "\">"],
+              [:mustache, :etag, [:mustache, :fetch, ["name"]], [7, 29]],
+              [:static, "</a></li>\n"]],
+            %Q'  <li><a href="{{url}}">{{name}}</a></li>\n',
+            %w[{{ }}]]],
+        %Q'{{#first}}\n  <li><strong>{{name}}</strong></li>\n{{/first}}\n{{#link}}\n  <li><a href="{{url}}">{{name}}</a></li>\n{{/link}}\n',
+        %w[{{ }}]],
+      [:static, "\n"],
+      [:mustache,
+        :section,
+        [:mustache, :fetch, ["empty"]],
+        [11, 7],
+        [:multi, [:static, "<p>The list is empty.</p>\n"]],
+        %Q'<p>The list is empty.</p>\n',
+        %w[{{ }}]]]
+
+    assert_equal expected, tokens
+  end
+
+  def test_raw_content_and_whitespace
+    lexer = Mustache::Parser.new
+    tokens = lexer.compile("{{#list}}\t{{/list}}")
+
+    expected = [:multi,
+      [:mustache,
+        :section,
+        [:mustache, :fetch, ["list"]],
+        [1, 6],
+        [:multi, [:static, "\t"]],
+        "\t",
+        %w[{{ }}]]]
+
+    assert_equal expected, tokens
+  end
+
+  def test_unclosed_section
+    lexer = Mustache::Parser.new
+    exception = assert_raises Mustache::Parser::SyntaxError do
+      lexer.compile("{{#list}}")
+    end
+
+    expected = <<-EOF
+Unclosed section "list"
+  Line 1
+    {{#list}}
+          ^
+EOF
+
+    assert_equal expected, exception.message
+  end
+
+  def test_closing_unopened
+    lexer = Mustache::Parser.new
+    exception = assert_raises Mustache::Parser::SyntaxError do
+      lexer.compile("{{/list}}")
+    end
+
+    expected = <<-EOF
+Closing unopened "list"
+  Line 1
+    {{/list}}
+          ^
+EOF
+
+    assert_equal expected, exception.message
+  end
+
+  def test_unclosed_tag
+    lexer = Mustache::Parser.new
+    exception = assert_raises Mustache::Parser::SyntaxError do
+      lexer.compile("{{list")
+    end
+
+    expected = <<-EOF
+Unclosed tag
+  Line 1
+    {{list
+         ^
+EOF
+
+    assert_equal expected, exception.message
+  end
+
+  def test_illegal_content
+    lexer = Mustache::Parser.new
+    exception = assert_raises Mustache::Parser::SyntaxError do
+      lexer.compile("{{")
+    end
+
+    expected = <<-EOF
+Illegal content in tag
+  Line 1
+    {{
+     ^
+EOF
+
+    assert_equal expected, exception.message
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/test/partial_test.rb

@@ -0,0 +1,180 @@
+require_relative 'helper'
+
+class PartialTest < Minitest::Test
+  def test_view_partial
+    assert_equal <<-end_partial.strip, PartialWithModule.render
+<h1>Welcome</h1>
+Hello Bob
+You have just won $100000!
+
+<h3>Fair enough, right?</h3>
+end_partial
+  end
+
+  def test_partial_with_slashes
+    klass = Class.new(Mustache)
+    klass.template = '{{> test/fixtures/inner_partial}}'
+    view = klass.new
+    view[:title] = 'success'
+
+    assert_equal "Again, success!", view.render
+  end
+
+  def test_partial_inlining
+    view = Mustache.new :inline_partials_at_compile_time => true
+    view.template = '{{> test/fixtures/inner_partial}}'
+    view[:title] = 'success'
+
+    # Test the rendered result first
+    assert_equal "Again, success!", view.render
+
+    # Now the template should be compiled.
+    # There should be no :partial instruction as the partial has been in-lined.
+    assert_equal false, view.template.tokens.flatten.include?(:partial)
+  end
+
+  def test_view_partial_inherits_context
+    klass = Class.new(TemplatePartial)
+    view = klass.new
+    view.template_path = File.dirname(__FILE__) + '/fixtures'
+    view[:titles] = [{:title => :One}, {:title => :Two}]
+    view.template = <<-end_template
+<h1>Context Test</h1>
+<ul>
+{{#titles}}
+<li>{{>inner_partial}}</li>
+{{/titles}}
+</ul>
+end_template
+    assert_equal <<-end_partial, view.render
+<h1>Context Test</h1>
+<ul>
+<li>Again, One!</li>
+<li>Again, Two!</li>
+</ul>
+end_partial
+  end
+
+  def test_view_partial_inherits_context_of_class_methods
+    klass = Class.new(TemplatePartial)
+    klass.template_path = File.dirname(__FILE__) + '/fixtures'
+    klass.send(:define_method, :titles) do
+      [{:title => :One}, {:title => :Two}]
+    end
+    view = klass.new
+    view.template = <<-end_template
+<h1>Context Test</h1>
+<ul>
+{{#titles}}
+<li>{{>inner_partial}}</li>
+{{/titles}}
+</ul>
+end_template
+    assert_equal <<-end_partial, view.render
+<h1>Context Test</h1>
+<ul>
+<li>Again, One!</li>
+<li>Again, Two!</li>
+</ul>
+end_partial
+  end
+
+  def test_template_partial
+    assert_equal <<-end_partial.strip, TemplatePartial.render
+<h1>Welcome</h1>
+Again, Welcome!
+end_partial
+  end
+
+  def test_template_partial_with_custom_extension
+    partial = Class.new(TemplatePartial)
+    partial.template_extension = 'txt'
+    partial.template_path = File.dirname(__FILE__) + '/fixtures'
+
+    assert_equal <<-end_partial.strip, partial.render.strip
+Welcome
+-------
+
+## Again, Welcome! ##
+end_partial
+  end
+
+  def test_recursive_partials
+    assert_equal <<-end_partial, Recursive.render
+It works!
+end_partial
+  end
+
+  def test_crazy_recursive_partials
+    assert_equal <<-end_partial.strip, CrazyRecursive.render
+<html>
+  <body>
+    <ul>
+      <li>
+        1
+        <ul>
+          <li>
+            2
+            <ul>
+              <li>
+                3
+                <ul>
+                </ul>
+              </li>
+            </ul>
+          </li>
+          <li>
+            4
+            <ul>
+              <li>
+                5
+                <ul>
+                  <li>
+                    6
+                    <ul>
+                    </ul>
+                  </li>
+                </ul>
+              </li>
+            </ul>
+          </li>
+        </ul>
+      </li>
+    </ul>
+  </body>
+</html>
+end_partial
+  end
+
+  def test_partials_use_proper_context
+    assert_equal "OuterThing OuterThing", OuterThing.render('{{name}} {{> p}}')
+
+    assert_equal "InnerThing InnerThing", InnerThing.render('{{name}} {{> p}}')
+
+    assert_equal "OuterThing InnerThing InnerThing",
+      OuterThing.render('{{name}} {{#inner}}{{name}} {{> p}}{{/inner}}')
+  end
+
+  def test_partials_render_returned_strings
+    assert_equal "ok", MiddleThing.render('{{> some_partial }}')
+  end
+end
+
+class InnerThing < Mustache
+  def partial(p) self.class end
+  def name;      self.class end
+end
+
+class OuterThing < Mustache
+  def inner
+    InnerThing.new
+  end
+
+  def partial(p) self.class end
+  def name;      self.class end
+end
+
+class MiddleThing < Mustache
+  def partial(name) "{{#{name}}}" end
+  def some_partial; "ok" end
+end

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/test/spec_test.rb

@@ -0,0 +1,68 @@
+require 'mustache'
+require 'tmpdir'
+require 'yaml'
+require 'minitest/autorun'
+
+# Calls appropriate method on YAML. See: https://gist.github.com/tenderlove/958999ab4240b93bd3cd
+YAML.add_domain_type(nil, 'code') { |_, val| eval(val['ruby']) }
+
+# A simple base class for Mustache specs.
+# Creates a partials directory, then points a (dynamic) subclass of Mustache at
+# that directory before each test; the partials directory is destroyed after
+# each test is run.
+class MustacheSpec < Minitest::Test
+  def setup
+    @partials = File.join(File.dirname(__FILE__), 'partials')
+    Dir.mkdir(@partials)
+
+    @Mustache = Class.new(Mustache)
+    @Mustache.template_path = @partials
+  end
+
+  def teardown
+    Dir[File.join(@partials, '*')].each { |file| File.delete(file) }
+    Dir.rmdir(@partials)
+  end
+
+  # Extracts the partials from the test, and dumps them into the partials
+  # directory for inclusion.
+  def setup_partials(test)
+    (test['partials'] || {}).each do |name, content|
+      File.open(File.join(@partials, "#{name}.mustache"), 'w') do |f|
+        f.print(content)
+      end
+    end
+  end
+
+  # Asserts equality between the rendered template and the expected value,
+  # printing additional context data on failure.
+  def assert_mustache_spec(test)
+    actual = @Mustache.render(test['template'], test['data'])
+
+    assert_equal test['expected'], actual, "" <<
+      "#{ test['desc'] }\n" <<
+      "Data: #{ test['data'].inspect }\n" <<
+      "Template: #{ test['template'].inspect }\n" <<
+      "Partials: #{ (test['partials'] || {}).inspect }\n"
+  end
+
+  def test_noop; assert(true); end
+end
+
+spec_files = File.join(File.dirname(__FILE__), '..', 'ext', 'spec', 'specs', '*.yml')
+Dir[spec_files].each do |file|
+  spec = YAML.load_file(file)
+
+  klass_name = "Test" + File.basename(file, ".yml").sub(/~/, '').capitalize
+  instance_eval "class ::#{klass_name} < MustacheSpec; end"
+  test_suite = Kernel.const_get(klass_name)
+
+  test_suite.class_eval do
+    spec['tests'].each do |test|
+      define_method :"test_spec - #{test['name']}" do
+        setup_partials(test)
+        assert_mustache_spec(test)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/mustache-1.1.1/test/template_test.rb

@@ -0,0 +1,52 @@
+require_relative 'helper'
+
+class TemplateTest < Minitest::Test
+  def test_compile
+    assert_equal %("foo"), Mustache::Template.new("foo").compile
+  end
+
+  def test_compile_with_source
+    assert_equal %("bar"), Mustache::Template.new("foo").compile("bar")
+  end
+
+  def test_token
+    assert_equal [:multi, [:static, "foo"]], Mustache::Template.new("foo").tokens
+  end
+
+  def test_token_with_source
+    assert_equal [:multi, [:static, "bar"]], Mustache::Template.new("foo").tokens("bar")
+  end
+end
+
+class TemplateTest2 < Minitest::Test
+  def setup
+    @@template_text ||= File.read(File.dirname(__FILE__) + "/fixtures/simply_complicated.mustache")
+    @template = Mustache::Template.new(@@template_text)
+  end
+
+  def test_tags
+    assert_equal [
+      "yourname",
+      "HOME",
+      "friend.name",
+      "friend.morr.word",
+      "friend.morr.up",
+      "friend.morr.awesomesauce",
+      "friend.morr.hiss",
+      "friend.notinmorr",
+      "friend.person",
+      "love",
+      "triplestash"
+      ], @template.tags
+  end
+
+  def test_partials
+    assert_equal ["partial1", "partial2"], @template.partials
+  end
+
+  def test_sections
+    assert_equal ["friend", "friend.morr"], @template.sections
+  end
+end
+
+