liquid 5.3.0 → 5.4.0

data/test/test_helper.rb

@@ -1,207 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-ENV["MT_NO_EXPECTATIONS"] = "1"
-require 'minitest/autorun'
-
-$LOAD_PATH.unshift(File.join(File.expand_path(__dir__), '..', 'lib'))
-require 'liquid.rb'
-require 'liquid/profiler'
-
-mode = :strict
-if (env_mode = ENV['LIQUID_PARSER_MODE'])
-  puts "-- #{env_mode.upcase} ERROR MODE"
-  mode = env_mode.to_sym
-end
-Liquid::Template.error_mode = mode
-
-if ENV['LIQUID_C'] == '1'
-  puts "-- LIQUID C"
-  require 'liquid/c'
-end
-
-if Minitest.const_defined?('Test')
-  # We're on Minitest 5+. Nothing to do here.
-else
-  # Minitest 4 doesn't have Minitest::Test yet.
-  Minitest::Test = MiniTest::Unit::TestCase
-end
-
-module Minitest
-  class Test
-    def fixture(name)
-      File.join(File.expand_path(__dir__), "fixtures", name)
-    end
-  end
-
-  module Assertions
-    include Liquid
-
-    def assert_template_result(expected, template, assigns = {}, message = nil)
-      assert_equal(expected, Template.parse(template, line_numbers: true).render!(assigns), message)
-    end
-
-    def assert_template_result_matches(expected, template, assigns = {}, message = nil)
-      return assert_template_result(expected, template, assigns, message) unless expected.is_a?(Regexp)
-
-      assert_match(expected, Template.parse(template, line_numbers: true).render!(assigns), message)
-    end
-
-    def assert_match_syntax_error(match, template, assigns = {})
-      exception = assert_raises(Liquid::SyntaxError) do
-        Template.parse(template, line_numbers: true).render(assigns)
-      end
-      assert_match(match, exception.message)
-    end
-
-    def assert_usage_increment(name, times: 1)
-      old_method = Liquid::Usage.method(:increment)
-      calls = 0
-      begin
-        Liquid::Usage.singleton_class.send(:remove_method, :increment)
-        Liquid::Usage.define_singleton_method(:increment) do |got_name|
-          calls += 1 if got_name == name
-          old_method.call(got_name)
-        end
-        yield
-      ensure
-        Liquid::Usage.singleton_class.send(:remove_method, :increment)
-        Liquid::Usage.define_singleton_method(:increment, old_method)
-      end
-      assert_equal(times, calls, "Number of calls to Usage.increment with #{name.inspect}")
-    end
-
-    def with_global_filter(*globals)
-      original_global_cache = Liquid::StrainerFactory::GlobalCache
-      Liquid::StrainerFactory.send(:remove_const, :GlobalCache)
-      Liquid::StrainerFactory.const_set(:GlobalCache, Class.new(Liquid::StrainerTemplate))
-
-      globals.each do |global|
-        Liquid::Template.register_filter(global)
-      end
-      Liquid::StrainerFactory.send(:strainer_class_cache).clear
-      begin
-        yield
-      ensure
-        Liquid::StrainerFactory.send(:remove_const, :GlobalCache)
-        Liquid::StrainerFactory.const_set(:GlobalCache, original_global_cache)
-        Liquid::StrainerFactory.send(:strainer_class_cache).clear
-      end
-    end
-
-    def with_error_mode(mode)
-      old_mode = Liquid::Template.error_mode
-      Liquid::Template.error_mode = mode
-      yield
-    ensure
-      Liquid::Template.error_mode = old_mode
-    end
-
-    def with_custom_tag(tag_name, tag_class)
-      old_tag = Liquid::Template.tags[tag_name]
-      begin
-        Liquid::Template.register_tag(tag_name, tag_class)
-        yield
-      ensure
-        if old_tag
-          Liquid::Template.tags[tag_name] = old_tag
-        else
-          Liquid::Template.tags.delete(tag_name)
-        end
-      end
-    end
-  end
-end
-
-class ThingWithToLiquid
-  def to_liquid
-    'foobar'
-  end
-end
-
-class IntegerDrop < Liquid::Drop
-  def initialize(value)
-    super()
-    @value = value.to_i
-  end
-
-  def ==(other)
-    @value == other
-  end
-
-  def to_s
-    @value.to_s
-  end
-
-  def to_liquid_value
-    @value
-  end
-end
-
-class BooleanDrop < Liquid::Drop
-  def initialize(value)
-    super()
-    @value = value
-  end
-
-  def ==(other)
-    @value == other
-  end
-
-  def to_liquid_value
-    @value
-  end
-
-  def to_s
-    @value ? "Yay" : "Nay"
-  end
-end
-
-class ErrorDrop < Liquid::Drop
-  def standard_error
-    raise Liquid::StandardError, 'standard error'
-  end
-
-  def argument_error
-    raise Liquid::ArgumentError, 'argument error'
-  end
-
-  def syntax_error
-    raise Liquid::SyntaxError, 'syntax error'
-  end
-
-  def runtime_error
-    raise 'runtime error'
-  end
-
-  def exception
-    raise Exception, 'exception'
-  end
-end
-
-class StubFileSystem
-  attr_reader :file_read_count
-
-  def initialize(values)
-    @file_read_count = 0
-    @values          = values
-  end
-
-  def read_template_file(template_path)
-    @file_read_count += 1
-    @values.fetch(template_path)
-  end
-end
-
-class StubTemplateFactory
-  attr_reader :count
-
-  def initialize
-    @count = 0
-  end
-
-  def for(_template_name)
-    @count += 1
-    Liquid::Template.new
-  end
-end

data/test/unit/block_unit_test.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class BlockUnitTest < Minitest::Test
-  include Liquid
-
-  def test_blankspace
-    template = Liquid::Template.parse("  ")
-    assert_equal(["  "], template.root.nodelist)
-  end
-
-  def test_variable_beginning
-    template = Liquid::Template.parse("{{funk}}  ")
-    assert_equal(2, template.root.nodelist.size)
-    assert_equal(Variable, template.root.nodelist[0].class)
-    assert_equal(String, template.root.nodelist[1].class)
-  end
-
-  def test_variable_end
-    template = Liquid::Template.parse("  {{funk}}")
-    assert_equal(2, template.root.nodelist.size)
-    assert_equal(String, template.root.nodelist[0].class)
-    assert_equal(Variable, template.root.nodelist[1].class)
-  end
-
-  def test_variable_middle
-    template = Liquid::Template.parse("  {{funk}}  ")
-    assert_equal(3, template.root.nodelist.size)
-    assert_equal(String, template.root.nodelist[0].class)
-    assert_equal(Variable, template.root.nodelist[1].class)
-    assert_equal(String, template.root.nodelist[2].class)
-  end
-
-  def test_variable_many_embedded_fragments
-    template = Liquid::Template.parse("  {{funk}} {{so}} {{brother}} ")
-    assert_equal(7, template.root.nodelist.size)
-    assert_equal([String, Variable, String, Variable, String, Variable, String],
-      block_types(template.root.nodelist))
-  end
-
-  def test_with_block
-    template = Liquid::Template.parse("  {% comment %} {% endcomment %} ")
-    assert_equal([String, Comment, String], block_types(template.root.nodelist))
-    assert_equal(3, template.root.nodelist.size)
-  end
-
-  private
-
-  def block_types(nodelist)
-    nodelist.collect(&:class)
-  end
-end

data/test/unit/condition_unit_test.rb

@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ConditionUnitTest < Minitest::Test
-  include Liquid
-
-  def setup
-    @context = Liquid::Context.new
-  end
-
-  def test_basic_condition
-    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
-    assert_evaluates_true(1, '==', 1)
-    assert_evaluates_true(1, '!=', 2)
-    assert_evaluates_true(1, '<>', 2)
-    assert_evaluates_true(1, '<', 2)
-    assert_evaluates_true(2, '>', 1)
-    assert_evaluates_true(1, '>=', 1)
-    assert_evaluates_true(2, '>=', 1)
-    assert_evaluates_true(1, '<=', 2)
-    assert_evaluates_true(1, '<=', 1)
-    # negative numbers
-    assert_evaluates_true(1, '>', -1)
-    assert_evaluates_true(-1, '<', 1)
-    assert_evaluates_true(1.0, '>', -1.0)
-    assert_evaluates_true(-1.0, '<', 1.0)
-  end
-
-  def test_default_operators_evalute_false
-    assert_evaluates_false(1, '==', 2)
-    assert_evaluates_false(1, '!=', 1)
-    assert_evaluates_false(1, '<>', 1)
-    assert_evaluates_false(1, '<', 0)
-    assert_evaluates_false(2, '>', 4)
-    assert_evaluates_false(1, '>=', 3)
-    assert_evaluates_false(2, '>=', 4)
-    assert_evaluates_false(1, '<=', 0)
-    assert_evaluates_false(1, '<=', 0)
-  end
-
-  def test_contains_works_on_strings
-    assert_evaluates_true('bob', 'contains', 'o')
-    assert_evaluates_true('bob', 'contains', 'b')
-    assert_evaluates_true('bob', 'contains', 'bo')
-    assert_evaluates_true('bob', 'contains', 'ob')
-    assert_evaluates_true('bob', 'contains', 'bob')
-
-    assert_evaluates_false('bob', 'contains', 'bob2')
-    assert_evaluates_false('bob', 'contains', 'a')
-    assert_evaluates_false('bob', 'contains', '---')
-  end
-
-  def test_invalid_comparation_operator
-    assert_evaluates_argument_error(1, '~~', 0)
-  end
-
-  def test_comparation_of_int_and_str
-    assert_evaluates_argument_error('1', '>', 0)
-    assert_evaluates_argument_error('1', '<', 0)
-    assert_evaluates_argument_error('1', '>=', 0)
-    assert_evaluates_argument_error('1', '<=', 0)
-  end
-
-  def test_hash_compare_backwards_compatibility
-    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
-    @context          = Liquid::Context.new
-    @context['array'] = [1, 2, 3, 4, 5]
-    array_expr        = VariableLookup.new("array")
-
-    assert_evaluates_false(array_expr, 'contains', 0)
-    assert_evaluates_true(array_expr, 'contains', 1)
-    assert_evaluates_true(array_expr, 'contains', 2)
-    assert_evaluates_true(array_expr, 'contains', 3)
-    assert_evaluates_true(array_expr, 'contains', 4)
-    assert_evaluates_true(array_expr, 'contains', 5)
-    assert_evaluates_false(array_expr, 'contains', 6)
-    assert_evaluates_false(array_expr, 'contains', "1")
-  end
-
-  def test_contains_returns_false_for_nil_operands
-    @context = Liquid::Context.new
-    assert_evaluates_false(VariableLookup.new('not_assigned'), 'contains', '0')
-    assert_evaluates_false(0, 'contains', VariableLookup.new('not_assigned'))
-  end
-
-  def test_contains_return_false_on_wrong_data_type
-    assert_evaluates_false(1, 'contains', 0)
-  end
-
-  def test_contains_with_string_left_operand_coerces_right_operand_to_string
-    assert_evaluates_true(' 1 ', 'contains', 1)
-    assert_evaluates_false(' 1 ', 'contains', 2)
-  end
-
-  def test_or_condition
-    condition = Condition.new(1, '==', 2)
-    assert_equal(false, condition.evaluate(Context.new))
-
-    condition.or(Condition.new(2, '==', 1))
-
-    assert_equal(false, condition.evaluate(Context.new))
-
-    condition.or(Condition.new(1, '==', 1))
-
-    assert_equal(true, condition.evaluate(Context.new))
-  end
-
-  def test_and_condition
-    condition = Condition.new(1, '==', 1)
-
-    assert_equal(true, condition.evaluate(Context.new))
-
-    condition.and(Condition.new(2, '==', 2))
-
-    assert_equal(true, condition.evaluate(Context.new))
-
-    condition.and(Condition.new(2, '==', 1))
-
-    assert_equal(false, condition.evaluate(Context.new))
-  end
-
-  def test_should_allow_custom_proc_operator
-    Condition.operators['starts_with'] = proc { |_cond, left, right| left =~ /^#{right}/ }
-
-    assert_evaluates_true('bob', 'starts_with', 'b')
-    assert_evaluates_false('bob', 'starts_with', 'o')
-  ensure
-    Condition.operators.delete('starts_with')
-  end
-
-  def test_left_or_right_may_contain_operators
-    @context        = Liquid::Context.new
-    @context['one'] = @context['another'] = "gnomeslab-and-or-liquid"
-
-    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)
-    assert(Condition.new(left, op, right).evaluate(@context),
-      "Evaluated false: #{left} #{op} #{right}")
-  end
-
-  def assert_evaluates_false(left, op, right)
-    assert(!Condition.new(left, op, right).evaluate(@context),
-      "Evaluated true: #{left} #{op} #{right}")
-  end
-
-  def assert_evaluates_argument_error(left, op, right)
-    assert_raises(Liquid::ArgumentError) do
-      Condition.new(left, op, right).evaluate(@context)
-    end
-  end
-end # ConditionTest

data/test/unit/file_system_unit_test.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class FileSystemUnitTest < Minitest::Test
-  include Liquid
-
-  def test_default
-    assert_raises(FileSystemError) do
-      BlankFileSystem.new.read_template_file("dummy")
-    end
-  end
-
-  def test_local
-    file_system = Liquid::LocalFileSystem.new("/some/path")
-    assert_equal("/some/path/_mypartial.liquid", file_system.full_path("mypartial"))
-    assert_equal("/some/path/dir/_mypartial.liquid", file_system.full_path("dir/mypartial"))
-
-    assert_raises(FileSystemError) do
-      file_system.full_path("../dir/mypartial")
-    end
-
-    assert_raises(FileSystemError) do
-      file_system.full_path("/dir/../../dir/mypartial")
-    end
-
-    assert_raises(FileSystemError) do
-      file_system.full_path("/etc/passwd")
-    end
-  end
-
-  def test_custom_template_filename_patterns
-    file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
-    assert_equal("/some/path/mypartial.html", file_system.full_path("mypartial"))
-    assert_equal("/some/path/dir/mypartial.html", file_system.full_path("dir/mypartial"))
-  end
-end # FileSystemTest

data/test/unit/i18n_unit_test.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class I18nUnitTest < Minitest::Test
-  include Liquid
-
-  def setup
-    @i18n = I18n.new(fixture("en_locale.yml"))
-  end
-
-  def test_simple_translate_string
-    assert_equal("less is more", @i18n.translate("simple"))
-  end
-
-  def test_nested_translate_string
-    assert_equal("something wasn't right", @i18n.translate("errors.syntax.oops"))
-  end
-
-  def test_single_string_interpolation
-    assert_equal("something different", @i18n.translate("whatever", something: "different"))
-  end
-
-  # def test_raises_translation_error_on_undefined_interpolation_key
-  #   assert_raises I18n::TranslationError do
-  #     @i18n.translate("whatever", :oopstypos => "yes")
-  #   end
-  # end
-
-  def test_raises_unknown_translation
-    assert_raises(I18n::TranslationError) do
-      @i18n.translate("doesnt_exist")
-    end
-  end
-
-  def test_sets_default_path_to_en
-    assert_equal(I18n::DEFAULT_LOCALE, I18n.new.path)
-  end
-end

data/test/unit/lexer_unit_test.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class LexerUnitTest < Minitest::Test
-  include Liquid
-
-  def test_strings
-    tokens = Lexer.new(%( 'this is a test""' "wat 'lol'")).tokenize
-    assert_equal([[:string, %('this is a test""')], [:string, %("wat 'lol'")], [:end_of_string]], tokens)
-  end
-
-  def test_integer
-    tokens = Lexer.new('hi 50').tokenize
-    assert_equal([[:id, 'hi'], [:number, '50'], [:end_of_string]], tokens)
-  end
-
-  def test_float
-    tokens = Lexer.new('hi 5.0').tokenize
-    assert_equal([[:id, 'hi'], [:number, '5.0'], [:end_of_string]], tokens)
-  end
-
-  def test_comparison
-    tokens = Lexer.new('== <> contains ').tokenize
-    assert_equal([[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens)
-  end
-
-  def test_specials
-    tokens = Lexer.new('| .:').tokenize
-    assert_equal([[:pipe, '|'], [:dot, '.'], [:colon, ':'], [:end_of_string]], tokens)
-    tokens = Lexer.new('[,]').tokenize
-    assert_equal([[:open_square, '['], [:comma, ','], [:close_square, ']'], [:end_of_string]], tokens)
-  end
-
-  def test_fancy_identifiers
-    tokens = Lexer.new('hi five?').tokenize
-    assert_equal([[:id, 'hi'], [:id, 'five?'], [:end_of_string]], tokens)
-
-    tokens = Lexer.new('2foo').tokenize
-    assert_equal([[:number, '2'], [:id, 'foo'], [:end_of_string]], tokens)
-  end
-
-  def test_whitespace
-    tokens = Lexer.new("five|\n\t ==").tokenize
-    assert_equal([[:id, 'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]], tokens)
-  end
-
-  def test_unexpected_character
-    assert_raises(SyntaxError) do
-      Lexer.new("%").tokenize
-    end
-  end
-end