require 'test_helper'

class IteratingTest < ActiveSupport::TestCase

  class Context
    def initialize ; @things = ['bar', 'baz'] ; @empty = [] ; end
  end

  class ForEachLogic < ECB
    emits -> {
      for_each(:@things) {
        span { thing }
      }
    }
  end

  test "#for_each expands to view logic" do
    compiled = ForEachLogic.new.compile
    assert_equal %q((@things.each_with_index.map do |thing, thing_index|
"<span>"+%Q(#{thing})+"</span>"
end).join), Interpolator.transform(compiled)
  end

  test "#for_each iterates markup for each value" do
    compiled = ForEachLogic.new.compile
    assert_equal '<span>bar</span><span>baz</span>',
                 Context.new.instance_eval(Interpolator.transform(compiled))
  end

  class AnyContainer < ExpressTemplates::Components::Container
    emits -> {
      p {
        _yield
      }
    }
  end

  test "a template utilizing a component with for_each inside another component" do
    fragment = -> {
      any_container {
        for_each_logic  # <-- this is causing an exception when AnyContainer
      }
    }
    compiled = ExpressTemplates.compile(&fragment)
    assert_equal '<p><span>bar</span><span>baz</span></p>', Context.new.instance_eval(compiled)
  end

  class ForEachDeclarativeForm < ECB
    emits -> {
      span { thing }
    }

    for_each(:@things)
  end

  test ".for_each offers declarative form" do
    compiled = ForEachLogic.new.compile
    assert_equal '<span>bar</span><span>baz</span>',
                  Context.new.instance_eval(Interpolator.transform(compiled))
  end


  class MultiFragments < ECB

    fragments item:  -> {
                          li { thing }
                        },

              wrapper: -> {
                            ul {
                              _yield
                            }
                          }

    for_each -> { @things }, as: 'thing', emit: :item

    wrap_with :wrapper

  end

  test ".wrap_with wraps via _yield special handler" do
    compiled = MultiFragments.new.compile
    assert_equal "<ul><li>bar</li><li>baz</li></ul>",
                  Context.new.instance_eval(Interpolator.transform(compiled))
  end

  class EmptyState < ECB

    fragments item:       -> {
                                li { thing }
                              },

              wrapper:    -> {
                                ul {
                                  _yield
                                }
                             },
              empty_state: -> {
                                p "Nothing here"
                              }

    for_each -> { @empty }, as: 'thing', emit: :item, empty: :empty_state

    wrap_with :wrapper, dont_wrap_if: -> { @empty.empty? }

  end

  test "empty state renders when collection is empty" do
    compiled = EmptyState.new.compile
    assert_equal '<p>Nothing here</p>', Context.new.instance_eval(compiled)
  end

  class EmptyEmptyState < ECB
    emits -> {
      whatever
    }

    for_each -> { @empty }
  end

  test "if collection is empty and no empty fragment specified, empty string is rendered" do
    compiled = EmptyEmptyState.new.compile
    assert_equal '', Context.new.instance_eval(compiled)
  end


end