liquid 4.0.3 → 5.4.0

data/test/test_helper.rb

@@ -1,116 +0,0 @@
-#!/usr/bin/env ruby
-
-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).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).render!(assigns), message
-    end
-
-    def assert_match_syntax_error(match, template, assigns = {})
-      exception = assert_raises(Liquid::SyntaxError) do
-        Template.parse(template).render(assigns)
-      end
-      assert_match match, exception.message
-    end
-
-    def with_global_filter(*globals)
-      original_global_strainer = Liquid::Strainer.class_variable_get(:@@global_strainer)
-      Liquid::Strainer.class_variable_set(:@@global_strainer, Class.new(Liquid::Strainer) do
-        @filter_methods = Set.new
-      end)
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
-
-      globals.each do |global|
-        Liquid::Template.register_filter(global)
-      end
-      yield
-    ensure
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
-      Liquid::Strainer.class_variable_set(:@@global_strainer, original_global_strainer)
-    end
-
-    def with_taint_mode(mode)
-      old_mode = Liquid::Template.taint_mode
-      Liquid::Template.taint_mode = mode
-      yield
-    ensure
-      Liquid::Template.taint_mode = old_mode
-    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
-  end
-end
-
-class ThingWithToLiquid
-  def to_liquid
-    'foobar'
-  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

data/test/truffle/truffle_test.rb

@@ -1,9 +0,0 @@
-require 'test_helper'
-
-class TruffleTest < Minitest::Test
-  include Liquid
-
-  def test_truffle_works
-
-  end
-end

data/test/unit/block_unit_test.rb

@@ -1,58 +0,0 @@
-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
-
-  def test_with_custom_tag
-    Liquid::Template.register_tag("testtag", Block)
-    assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
-  ensure
-    Liquid::Template.tags.delete('testtag')
-  end
-
-  private
-
-  def block_types(nodelist)
-    nodelist.collect(&:class)
-  end
-end # VariableTest

data/test/unit/condition_unit_test.rb

@@ -1,166 +0,0 @@
-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
-    assert_equal true,  Condition.new(1, '==', 1).evaluate
-  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
-    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
-  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
-
-    condition.or Condition.new(2, '==', 1)
-
-    assert_equal false, condition.evaluate
-
-    condition.or Condition.new(1, '==', 1)
-
-    assert_equal true, condition.evaluate
-  end
-
-  def test_and_condition
-    condition = Condition.new(1, '==', 1)
-
-    assert_equal true, condition.evaluate
-
-    condition.and Condition.new(2, '==', 2)
-
-    assert_equal true, condition.evaluate
-
-    condition.and Condition.new(2, '==', 1)
-
-    assert_equal false, condition.evaluate
-  end
-
-  def test_should_allow_custom_proc_operator
-    Condition.operators['starts_with'] = proc { |cond, left, right| left =~ %r{^#{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
-
-  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