Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package rubygem-liquid for openSUSE:Factory checked in at 2022-04-30 22:52:29 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/rubygem-liquid (Old) and /work/SRC/openSUSE:Factory/.rubygem-liquid.new.1538 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "rubygem-liquid" Sat Apr 30 22:52:29 2022 rev:9 rq:974053 version:5.3.0 Changes: -------- --- /work/SRC/openSUSE:Factory/rubygem-liquid/rubygem-liquid.changes 2022-03-04 20:20:49.152685089 +0100 +++ /work/SRC/openSUSE:Factory/.rubygem-liquid.new.1538/rubygem-liquid.changes 2022-04-30 22:52:38.508232692 +0200 @@ -1,0 +2,7 @@ +Thu Apr 28 05:34:44 UTC 2022 - Stephan Kulow <coolo@suse.com> + +updated to version 5.3.0 + see installed History.md + + +------------------------------------------------------------------- Old: ---- liquid-5.2.0.gem New: ---- liquid-5.3.0.gem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ rubygem-liquid.spec ++++++ --- /var/tmp/diff_new_pack.EuZtUC/_old 2022-04-30 22:52:39.124233526 +0200 +++ /var/tmp/diff_new_pack.EuZtUC/_new 2022-04-30 22:52:39.128233531 +0200 @@ -24,7 +24,7 @@ # Name: rubygem-liquid -Version: 5.2.0 +Version: 5.3.0 Release: 0 %define mod_name liquid %define mod_full_name %{mod_name}-%{version} ++++++ liquid-5.2.0.gem -> liquid-5.3.0.gem ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/History.md new/History.md --- old/History.md 2022-03-01 16:20:24.000000000 +0100 +++ new/History.md 2022-03-22 19:51:32.000000000 +0100 @@ -1,6 +1,16 @@ # Liquid Change Log -## 5.2.0 2021-03-01 +## 5.3.0 2022-03-22 + +### Fixes +* StandardFilter: Fix missing @context on iterations (#1525) [Thierry Joyal] +* Test under Ruby 3.1 (#1533) [petergoldstein] +* Fix warning about block and default value in `static_registers.rb` (#1531) [Peter Zhu] + +### Deprecation +* Condition#evaluate to require mandatory context argument in Liquid 6.0.0 (#1527) [Thierry Joyal] + +## 5.2.0 2022-03-01 ### Features * Add `remove_last`, and `replace_last` filters (#1422) [Anders Hagbard] @@ -10,7 +20,6 @@ * Fix some internal errors in filters from invalid input (#1476) [Dylan Thacker-Smith] * Allow dash in filter kwarg name for consistency with Liquid::C (#1518) [CP Clermont] - ## 5.1.0 / 2021-09-09 ### Features Binary files old/checksums.yaml.gz and new/checksums.yaml.gz differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/liquid/condition.rb new/lib/liquid/condition.rb --- old/lib/liquid/condition.rb 2022-03-01 16:20:24.000000000 +0100 +++ new/lib/liquid/condition.rb 2022-03-22 19:51:32.000000000 +0100 @@ -61,7 +61,7 @@ @child_condition = nil end - def evaluate(context = Context.new) + def evaluate(context = deprecated_default_context) condition = self result = nil loop do @@ -150,6 +150,12 @@ end end + def deprecated_default_context + warn("DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated" \ + " and will be removed from Liquid 6.0.0.") + Context.new + end + class ParseTreeVisitor < Liquid::ParseTreeVisitor def children [ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/liquid/standardfilters.rb new/lib/liquid/standardfilters.rb --- old/lib/liquid/standardfilters.rb 2022-03-01 16:20:24.000000000 +0100 +++ new/lib/liquid/standardfilters.rb 2022-03-22 19:51:32.000000000 +0100 @@ -582,8 +582,9 @@ def each @input.each do |e| + e = e.respond_to?(:to_liquid) ? e.to_liquid : e e.context = @context if e.respond_to?(:context=) - yield(e.respond_to?(:to_liquid) ? e.to_liquid : e) + yield(e) end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/liquid/static_registers.rb new/lib/liquid/static_registers.rb --- old/lib/liquid/static_registers.rb 2022-03-01 16:20:24.000000000 +0100 +++ new/lib/liquid/static_registers.rb 2022-03-22 19:51:32.000000000 +0100 @@ -31,7 +31,11 @@ if @registers.key?(key) @registers.fetch(key) elsif default != UNDEFINED - @static.fetch(key, default, &block) + if block_given? + @static.fetch(key, &block) + else + @static.fetch(key, default) + end else @static.fetch(key, &block) end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/liquid/version.rb new/lib/liquid/version.rb --- old/lib/liquid/version.rb 2022-03-01 16:20:24.000000000 +0100 +++ new/lib/liquid/version.rb 2022-03-22 19:51:32.000000000 +0100 @@ -2,5 +2,5 @@ # frozen_string_literal: true module Liquid - VERSION = "5.2.0" + VERSION = "5.3.0" end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/metadata new/metadata --- old/metadata 2022-03-01 16:20:24.000000000 +0100 +++ new/metadata 2022-03-22 19:51:32.000000000 +0100 @@ -1,14 +1,14 @@ --- !ruby/object:Gem::Specification name: liquid version: !ruby/object:Gem::Version - version: 5.2.0 + version: 5.3.0 platform: ruby authors: - Tobias L��tke autorequire: bindir: bin cert_chain: [] -date: 2022-03-01 00:00:00.000000000 Z +date: 2022-03-22 00:00:00.000000000 Z dependencies: - !ruby/object:Gem::Dependency name: rake @@ -193,61 +193,61 @@ specification_version: 4 summary: A secure, non-evaling end user template engine with aesthetic markup. test_files: -- test/integration/tag/disableable_test.rb -- test/integration/parsing_quirks_test.rb -- test/integration/context_test.rb +- test/unit/parser_unit_test.rb +- test/unit/static_registers_unit_test.rb +- test/unit/tag_unit_test.rb +- test/unit/strainer_factory_unit_test.rb +- test/unit/partial_cache_unit_test.rb +- test/unit/strainer_template_unit_test.rb +- test/unit/lexer_unit_test.rb +- test/unit/parse_tree_visitor_test.rb +- test/unit/i18n_unit_test.rb +- test/unit/tokenizer_unit_test.rb +- test/unit/template_factory_unit_test.rb +- test/unit/condition_unit_test.rb +- test/unit/block_unit_test.rb +- test/unit/file_system_unit_test.rb +- test/unit/variable_unit_test.rb +- test/unit/template_unit_test.rb +- test/unit/tags/if_tag_unit_test.rb +- test/unit/tags/case_tag_unit_test.rb +- test/unit/tags/for_tag_unit_test.rb +- test/unit/regexp_unit_test.rb +- test/test_helper.rb +- test/integration/document_test.rb +- test/integration/tag_test.rb - test/integration/filter_kwarg_test.rb -- test/integration/capture_test.rb - test/integration/trim_mode_test.rb +- test/integration/profiler_test.rb +- test/integration/security_test.rb +- test/integration/capture_test.rb +- test/integration/parsing_quirks_test.rb +- test/integration/blank_test.rb +- test/integration/template_test.rb +- test/integration/tag/disableable_test.rb +- test/integration/variable_test.rb - test/integration/output_test.rb -- test/integration/tags/raw_tag_test.rb -- test/integration/tags/continue_tag_test.rb -- test/integration/tags/increment_tag_test.rb -- test/integration/tags/if_else_tag_test.rb -- test/integration/tags/table_row_test.rb -- test/integration/tags/include_tag_test.rb +- test/integration/drop_test.rb +- test/integration/standard_filter_test.rb +- test/integration/expression_test.rb +- test/integration/block_test.rb +- test/integration/hash_ordering_test.rb +- test/integration/filter_test.rb - test/integration/tags/break_tag_test.rb -- test/integration/tags/unless_else_tag_test.rb - test/integration/tags/standard_tag_test.rb -- test/integration/tags/for_tag_test.rb -- test/integration/tags/statements_test.rb - test/integration/tags/liquid_tag_test.rb +- test/integration/tags/table_row_test.rb - test/integration/tags/render_tag_test.rb +- test/integration/tags/include_tag_test.rb +- test/integration/tags/increment_tag_test.rb +- test/integration/tags/if_else_tag_test.rb +- test/integration/tags/continue_tag_test.rb - test/integration/tags/echo_test.rb -- test/integration/drop_test.rb +- test/integration/tags/raw_tag_test.rb +- test/integration/tags/for_tag_test.rb +- test/integration/tags/statements_test.rb +- test/integration/tags/unless_else_tag_test.rb +- test/integration/context_test.rb - test/integration/error_handling_test.rb -- test/integration/template_test.rb -- test/integration/expression_test.rb -- test/integration/standard_filter_test.rb -- test/integration/tag_test.rb -- test/integration/hash_ordering_test.rb -- test/integration/security_test.rb -- test/integration/blank_test.rb -- test/integration/filter_test.rb -- test/integration/document_test.rb -- test/integration/block_test.rb -- test/integration/profiler_test.rb -- test/integration/variable_test.rb - test/integration/assign_test.rb -- test/unit/template_unit_test.rb -- test/unit/tag_unit_test.rb -- test/unit/condition_unit_test.rb -- test/unit/strainer_template_unit_test.rb -- test/unit/lexer_unit_test.rb -- test/unit/partial_cache_unit_test.rb -- test/unit/template_factory_unit_test.rb -- test/unit/tags/if_tag_unit_test.rb -- test/unit/tags/case_tag_unit_test.rb -- test/unit/tags/for_tag_unit_test.rb -- test/unit/static_registers_unit_test.rb -- test/unit/regexp_unit_test.rb -- test/unit/i18n_unit_test.rb -- test/unit/parse_tree_visitor_test.rb -- test/unit/variable_unit_test.rb -- test/unit/tokenizer_unit_test.rb -- test/unit/file_system_unit_test.rb -- test/unit/block_unit_test.rb -- test/unit/strainer_factory_unit_test.rb -- test/unit/parser_unit_test.rb -- test/test_helper.rb - test/fixtures/en_locale.yml diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/test/integration/context_test.rb new/test/integration/context_test.rb --- old/test/integration/context_test.rb 2022-03-01 16:20:24.000000000 +0100 +++ new/test/integration/context_test.rb 2022-03-22 19:51:32.000000000 +0100 @@ -24,7 +24,7 @@ end end -class Category < Liquid::Drop +class Category attr_accessor :name def initialize(name) @@ -36,8 +36,9 @@ end end -class CategoryDrop +class CategoryDrop < Liquid::Drop attr_accessor :category, :context + def initialize(category) @category = category end @@ -405,45 +406,42 @@ end def test_lambda_is_called_once + @global = 0 + @context['callcount'] = proc { - @global ||= 0 - @global += 1 + @global += 1 @global.to_s } assert_equal('1', @context['callcount']) assert_equal('1', @context['callcount']) assert_equal('1', @context['callcount']) - - @global = nil end def test_nested_lambda_is_called_once + @global = 0 + @context['callcount'] = { "lambda" => proc { - @global ||= 0 - @global += 1 + @global += 1 @global.to_s } } assert_equal('1', @context['callcount.lambda']) assert_equal('1', @context['callcount.lambda']) assert_equal('1', @context['callcount.lambda']) - - @global = nil end def test_lambda_in_array_is_called_once + @global = 0 + @context['callcount'] = [1, 2, proc { - @global ||= 0 - @global += 1 + @global += 1 @global.to_s }, 4, 5] assert_equal('1', @context['callcount[2]']) assert_equal('1', @context['callcount[2]']) assert_equal('1', @context['callcount[2]']) - - @global = nil end def test_access_to_context_from_proc diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/test/integration/profiler_test.rb new/test/integration/profiler_test.rb --- old/test/integration/profiler_test.rb 2022-03-01 16:20:24.000000000 +0100 +++ new/test/integration/profiler_test.rb 2022-03-22 19:51:32.000000000 +0100 @@ -3,6 +3,27 @@ require 'test_helper' class ProfilerTest < Minitest::Test + class TestDrop < Liquid::Drop + def initialize(value) + super() + @value = value + end + + def to_s + artificial_execution_time + + @value + end + + private + + # Monotonic clock precision fluctuate based on the operating system + # By introducing a small sleep we ensure ourselves to register a non zero unit of time + def artificial_execution_time + sleep(Process.clock_getres(Process::CLOCK_MONOTONIC)) + end + end + include Liquid class ProfilingFileSystem @@ -198,16 +219,22 @@ def test_profiling_supports_self_time t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true) - t.render!("collection" => ["one", "two"]) - leaf = t.profiler[0].children[0] + collection = [ + TestDrop.new("one"), + TestDrop.new("two"), + ] + output = t.render!("collection" => collection) + assert_equal(" one two ", output) - assert_operator(leaf.self_time, :>, 0) + leaf = t.profiler[0].children[0] + assert_operator(leaf.self_time, :>, 0.0) end def test_profiling_supports_total_time - t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", profile: true) - t.render! + t = Template.parse("{% if true %} {{ test }} {% endif %}", profile: true) + output = t.render!("test" => TestDrop.new("one")) + assert_equal(" one ", output) - assert_operator(t.profiler[0].total_time, :>, 0) + assert_operator(t.profiler[0].total_time, :>, 0.0) end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/test/integration/standard_filter_test.rb new/test/integration/standard_filter_test.rb --- old/test/integration/standard_filter_test.rb 2022-03-01 16:20:24.000000000 +0100 +++ new/test/integration/standard_filter_test.rb 2022-03-22 19:51:32.000000000 +0100 @@ -3,10 +3,6 @@ require 'test_helper' -class Filters - include Liquid::StandardFilters -end - class TestThing attr_reader :foo @@ -29,8 +25,24 @@ end class TestDrop < Liquid::Drop - def test - "testfoo" + def initialize(value:) + @value = value + end + + attr_reader :value + + def registers + @context.registers + end +end + +class TestModel + def initialize(value:) + @value = value + end + + def to_liquid + TestDrop.new(value: @value) end end @@ -53,10 +65,13 @@ end class StandardFiltersTest < Minitest::Test + Filters = Class.new(Liquid::StrainerTemplate) + Filters.add_filter(Liquid::StandardFilters) + include Liquid def setup - @filters = Filters.new + @filters = Filters.new(Context.new) end def test_size @@ -363,8 +378,9 @@ assert_equal(["foo"], @filters.uniq("foo")) assert_equal([1, 3, 2, 4], @filters.uniq([1, 1, 3, 2, 3, 1, 4, 3, 2, 1])) assert_equal([{ "a" => 1 }, { "a" => 3 }, { "a" => 2 }], @filters.uniq([{ "a" => 1 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")) - testdrop = TestDrop.new - assert_equal([testdrop], @filters.uniq([testdrop, TestDrop.new], 'test')) + test_drop = TestDrop.new(value: "test") + test_drop_alternate = TestDrop.new(value: "test") + assert_equal([test_drop], @filters.uniq([test_drop, test_drop_alternate], 'value')) end def test_uniq_empty_array @@ -423,6 +439,16 @@ assert_template_result("woot: 1", '{{ foo | map: "whatever" }}', "foo" => [t]) end + def test_map_calls_context= + model = TestModel.new(value: "test") + + template = Template.parse('{{ foo | map: "registers" }}') + template.registers[:test] = 1234 + template.assigns['foo'] = [model] + + assert_template_result("{:test=>1234}", template.render!) + end + def test_map_on_hashes assert_template_result("4217", '{{ thing | map: "foo" | map: "bar" }}', "thing" => { "foo" => [{ "bar" => 42 }, { "bar" => 17 }] }) @@ -441,9 +467,9 @@ end def test_map_over_proc - drop = TestDrop.new + drop = TestDrop.new(value: "testfoo") p = proc { drop } - templ = '{{ procs | map: "test" }}' + templ = '{{ procs | map: "value" }}' assert_template_result("testfoo", templ, "procs" => [p]) end @@ -839,7 +865,7 @@ end def test_all_filters_never_raise_non_liquid_exception - test_drop = TestDrop.new + test_drop = TestDrop.new(value: "test") test_drop.context = Context.new test_enum = TestEnumerable.new test_enum.context = Context.new diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/test/unit/condition_unit_test.rb new/test/unit/condition_unit_test.rb --- old/test/unit/condition_unit_test.rb 2022-03-01 16:20:24.000000000 +0100 +++ new/test/unit/condition_unit_test.rb 2022-03-22 19:51:32.000000000 +0100 @@ -10,8 +10,8 @@ end def test_basic_condition - assert_equal(false, Condition.new(1, '==', 2).evaluate) - assert_equal(true, Condition.new(1, '==', 1).evaluate) + assert_equal(false, Condition.new(1, '==', 2).evaluate(Context.new)) + assert_equal(true, Condition.new(1, '==', 1).evaluate(Context.new)) end def test_default_operators_evalute_true @@ -67,11 +67,11 @@ end def test_hash_compare_backwards_compatibility - assert_nil(Condition.new({}, '>', 2).evaluate) - assert_nil(Condition.new(2, '>', {}).evaluate) - assert_equal(false, Condition.new({}, '==', 2).evaluate) - assert_equal(true, Condition.new({ 'a' => 1 }, '==', 'a' => 1).evaluate) - assert_equal(true, Condition.new({ 'a' => 2 }, 'contains', 'a').evaluate) + assert_nil(Condition.new({}, '>', 2).evaluate(Context.new)) + assert_nil(Condition.new(2, '>', {}).evaluate(Context.new)) + assert_equal(false, Condition.new({}, '==', 2).evaluate(Context.new)) + assert_equal(true, Condition.new({ 'a' => 1 }, '==', 'a' => 1).evaluate(Context.new)) + assert_equal(true, Condition.new({ 'a' => 2 }, 'contains', 'a').evaluate(Context.new)) end def test_contains_works_on_arrays @@ -106,30 +106,29 @@ def test_or_condition condition = Condition.new(1, '==', 2) - - assert_equal(false, condition.evaluate) + assert_equal(false, condition.evaluate(Context.new)) condition.or(Condition.new(2, '==', 1)) - assert_equal(false, condition.evaluate) + assert_equal(false, condition.evaluate(Context.new)) condition.or(Condition.new(1, '==', 1)) - assert_equal(true, condition.evaluate) + assert_equal(true, condition.evaluate(Context.new)) end def test_and_condition condition = Condition.new(1, '==', 1) - assert_equal(true, condition.evaluate) + assert_equal(true, condition.evaluate(Context.new)) condition.and(Condition.new(2, '==', 2)) - assert_equal(true, condition.evaluate) + assert_equal(true, condition.evaluate(Context.new)) condition.and(Condition.new(2, '==', 1)) - assert_equal(false, condition.evaluate) + assert_equal(false, condition.evaluate(Context.new)) end def test_should_allow_custom_proc_operator @@ -148,6 +147,20 @@ assert_evaluates_true(VariableLookup.new("one"), '==', VariableLookup.new("another")) end + def test_default_context_is_deprecated + if Gem::Version.new(Liquid::VERSION) >= Gem::Version.new('6.0.0') + flunk("Condition#evaluate without a context argument is to be removed") + end + + _out, err = capture_io do + assert_equal(true, Condition.new(1, '==', 1).evaluate) + end + + expected = "DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated" \ + " and will be removed from Liquid 6.0.0." + assert_includes(err.lines.map(&:strip), expected) + end + private def assert_evaluates_true(left, op, right)