express_templates 0.5.0 → 0.7.0

data/test/expander_stack_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-class ExpanderStackTest < ActiveSupport::TestCase
-
-  def new_stack
-    ExpressTemplates::Expander::Stack.new
-  end
-
-  test "#current is empty" do
-    assert_empty new_stack.current
-  end
-
-  test "#<< adds something to the current" do
-    stack = new_stack
-    stack << 'foo'
-    assert_equal ['foo'], stack.current
-  end
-
-  test "#all returns the stack" do
-    assert_equal [[]], new_stack.all
-  end
-
-  test "#descend! adds a level to the stack and updates current" do
-    stack = new_stack
-    stack << 'foo'
-    level = stack.descend!
-    assert_equal 2, stack.all.count
-    assert_equal [], stack.current
-    assert_equal 1, level
-  end
-
-  test "#ascend!" do
-    stack = new_stack
-    stack << 'foo'
-    level_1 = stack.descend!
-    level_2 = stack.descend!
-    level = stack.ascend!
-    assert_equal level_1, level
-  end
-
-end

data/test/expander_test.rb

@@ -1,99 +0,0 @@
-require 'test_helper'
-
-class ExpanderTest < ActiveSupport::TestCase
-
-  class Foo < ExpressTemplates::Markup::Tag ; end
-  class Bar < ExpressTemplates::Markup::Tag ; end
-  class Baz < ExpressTemplates::Markup::Tag ; end
-
-  ExpressTemplates::Expander.register_macros_for(Foo,Bar,Baz)
-
-  test "#expand returns an array containing a component" do
-    source = "foo"
-    result = ExpressTemplates::Expander.new(nil).expand(source)
-    assert_kind_of ExpressTemplates::Markup::Tag, result.first
-  end
-
-  test "#expand of 'foo { foo } returns a component with a child component" do
-    source = 'foo { foo }'
-    result = ExpressTemplates::Expander.new(nil).expand(source)
-    assert_kind_of Foo, result.first.children.first
-  end
-
-  test "#expand of 'foo { bar ; baz } returns a component with two children" do
-    source = 'foo { bar ; baz }'
-    result = ExpressTemplates::Expander.new(nil).expand(source)
-    assert_equal 2, result.first.children.size
-    assert_kind_of Bar, result.first.children.first
-    assert_kind_of Baz, result.first.children.last
-  end
-
-  test "#expand of macros with args returns a component with two children" do
-    source = 'foo { bar(fiz: "buzz") ; baz }'
-    result = ExpressTemplates::Expander.new(nil).expand(source)
-    assert_equal 2, result.first.children.size
-    assert_kind_of Bar, result.first.children.first
-    assert_kind_of Baz, result.first.children.last
-  end
-
-  test "#expand correctly allocated helpers and parameters" do
-    source = 'helper ; foo { buzz }'
-    result = ExpressTemplates::Expander.new(nil).expand(source)
-    assert_equal 0, result.first.children.size
-    assert_equal 1, result[1].children.size
-    assert_kind_of ExpressTemplates::Markup::Wrapper, result.first
-    assert_kind_of Foo, result[1]
-    assert_kind_of ExpressTemplates::Markup::Wrapper, result[1].children.first
-  end
-
-  test "#expand works with css class specification syntax xxx" do
-    source = 'foo.active { baz }'
-    result = ExpressTemplates::Expander.new(nil).expand(source)
-    assert_equal 1, result[0].children.size
-  end
-
-  test "#expand doesn't yield [] for children" do
-    source = %Q(ul(class: 'title-area') {
-  li.name {
-    a("Something", href: '#', disabled: true)
-  }
-  li(class:"ugly markup") {
-    a(href: "#") { span "menu item" }
-  }
-})
-    result = ExpressTemplates::Expander.new(nil).expand(source)
-    child_of_first_child = result.first.children.first
-    assert_equal 1, child_of_first_child.children.size
-    assert_kind_of ExpressTemplates::Markup::Tag, child_of_first_child.children.first
-  end
-
-  class Special
-    def self.render(label)
-      :dummy
-    end
-  end
-
-  test "initializer accepts special handlers hash" do
-    source = "render(:markup)"
-    assert_equal [:dummy], ExpressTemplates::Expander.new(nil, render: Special).expand(source)
-  end
-
-  test "helpers can take blocks" do
-    result = ExpressTemplates::Expander.new(nil).expand do
-      helper do
-        foo
-      end
-    end
-    assert_equal %q(%Q(#{helper do
-        foo
-      end})), Interpolator.transform(result.first.compile)
-  end
-
-  # NOTE: This probably should be deleted as {{helper}} is preferred
-  test "non-interpolated string children containing string interpolations will interpolate in context" do
-    source = 'p %q(some text #{helper})'
-    result = ExpressTemplates::Expander.new(nil).expand(source)
-    assert_equal %q("<p>"+"some text #{helper}"+"</p>"), result.first.compile
-  end
-
-end

data/test/markup/tag_test.rb

@@ -1,149 +0,0 @@
-require 'test_helper'
-
-class TagTest < ActiveSupport::TestCase
-
-  class Bare < ExpressTemplates::Markup::Tag ; end
-  class Sub < ExpressTemplates::Markup::Tag ; end
-
-  def bare_tag(*args)
-    Bare.new(*args)
-  end
-
-  def sub_tag(*args)
-    Sub.new(*args)
-  end
-
-
-  # NOTE: Due to formatting html leading newlines may be
-  # required for test values.  These are stripped for the
-  # first tag during ExpressTemplates.compile
-
-  test "#macro_name returns the name of the class" do
-    assert_equal 'bare', bare_tag.macro_name
-  end
-
-  test "#compile returns a string" do
-    assert_kind_of String, bare_tag.compile
-  end
-
-  test "has no children" do
-    assert_empty bare_tag.children
-  end
-
-  def bare_with_2_children
-    tag = bare_tag "child1", "child2"
-  end
-
-  test "can be created with children" do
-    assert_equal 2, bare_with_2_children.children.size
-    assert_equal "child2", bare_with_2_children.children.last
-  end
-
-  test "#compile on bare_with_2_children yields '\"<bare>\"+\"child1\"+\"child2\"+\"</bare>\"'" do
-    assert_equal '"<bare>"+"child1"+"child2"+"</bare>"', bare_with_2_children.compile
-  end
-
-  test "#start_tag is my macro_name as an xml start tag" do
-    assert_equal "<#{bare_tag.macro_name}>", bare_tag.start_tag
-  end
-
-  test "#close_tag is my macro_name as an xml close tag" do
-    assert_equal "</#{bare_tag.macro_name}>", bare_tag.close_tag
-  end
-
-  def tag_with_subtag
-    bare_tag sub_tag
-  end
-
-  test "#compile on tag_with_subtag returns a string which when eval'd looks like '<bare><sub /></bare>'" do
-    assert_equal '<bare><sub /></bare>', eval(tag_with_subtag.compile)
-  end
-
-  test "#to_template on bare_tag returns 'bare'" do
-    assert_equal 'bare', bare_tag.to_template
-  end
-
-  test "#to_template on tag_with_subtag returns 'bare {\n  sub\n}\n'" do
-    assert_equal "bare {\n  sub\n}\n", tag_with_subtag.to_template
-  end
-
-  test "#to_template on nested tags indents properly'" do
-    expected = %Q(bare {
-  sub {
-    sub
-  }
-}
-)
-    assert_equal expected, Bare.new(Sub.new(Sub.new)).to_template
-  end
-
-  test "double bracketed option values are substituted for evaluation in context" do
-    assert_equal '"<bare should_eval_in_context=\"#{foo}\" />"',
-                  Interpolator.transform(bare_tag(should_eval_in_context: "{{foo}}").compile)
-  end
-
-  test "double bracketed child values are substituted for evaluation in context" do
-    assert_equal '"<bare>"+"#{foo}"+"</bare>"',
-                  Interpolator.transform(bare_tag("{{foo}}").compile)
-  end
-
-  test "data option value hashes are converted to data attributes similar to haml" do
-    assert_equal %("<bare data-one=\\"two\\" data-three=\\"four\\" />"),
-                 bare_tag(data: {one: 'two', three: 'four'}).compile
-  end
-
-  test "data option value hashes can take immediate values" do
-    assert_equal %("<bare data-foo=\\"true\\" data-bar=\\"42\\" data-baz=\\"blah\\" />"),
-                 bare_tag(data: {foo: true, bar: 42, baz: 'blah'}).compile
-  end
-
-
-  # todo?
-  # test "proc option values are evaluated in context"
-
-  test "empty tags use abbreviated empty tag form" do
-    assert_equal '"<bare />"', bare_tag.compile
-  end
-
-  test "empty i tag does does not use abbreviated form since it is used for icons" do
-    assert_equal '"<i>"+"</i>"', ExpressTemplates::Markup::I.new.compile
-  end
-
-  test "method missing returns self" do
-    tag = bare_tag
-    assert_equal tag, tag.foo
-  end
-
-  # the block form of this is tested in expander
-  test "children still evaluated after css class provided via method syntax" do
-    assert_equal '"<bare class=\"foo\">"+"<sub />"+"</bare>"', (bare_tag.foo(sub_tag)).compile
-  end
-
-  test "CSS classes specified with underscored method get translated to dashed" do
-    assert_equal '"<bare class=\"foo-bar\" />"', bare_tag._foo_bar.compile
-  end
-
-  test "dom ID may be passed as a symbol" do
-    assert_equal '"<bare id=\"foo\" />"', bare_tag(:foo).compile
-  end
-
-  test "proc option values are evaluated in context" do
-    assert_equal '"<bare id=\"#{(-> { awesome }).call}\" />"', bare_tag(id: -> { awesome }).compile
-  end
-
-  test "markup is indented" do
-    ExpressTemplates::Markup::Tag.formatted do
-      code = ExpressTemplates.compile &-> {ul { li { "*"*36 }}}
-      assert_equal "\n<ul>\n  <li>#{"*"*36}</li>\n</ul>\n", eval(code)
-    end
-  end
-
-  test "print doctype for HTML5 document version" do
-    assert_equal '"<!DOCTYPE html>"', ExpressTemplates::Markup::Doctype.new.compile
-  end
-
-  test "void tags do not have trailing slash" do
-    assert_equal '"<img>"', ExpressTemplates::Markup::Img.new.compile
-  end
-
-end

data/test/markup/wrapper_test.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-class WrapperTest < ActiveSupport::TestCase
-
-  Wrapper = ExpressTemplates::Markup::Wrapper
-
-  test "name compiles to just name" do
-    assert_equal '%Q(#{foo})', Interpolator.transform(Wrapper.new('foo').compile)
-  end
-
-  test "simple args are preserved" do
-    wrapper =  Wrapper.new('foo', "xyzzy", 'bar', "baz", 1, false, 3)
-    assert_equal '%Q(#{foo("xyzzy", "bar", "baz", 1, false, 3)})', Interpolator.transform(wrapper.compile)
-  end
-
-  test "args are preserved" do
-    wrapper =  Wrapper.new('foo', "xyzzy", bar: "baz")
-    assert_equal '%Q(#{foo("xyzzy", bar: "baz")})', Interpolator.transform(wrapper.compile)
-  end
-
-  test "something returning nil when wrapped and compiled, evals to an empty string" do
-    assert_equal '', eval(Interpolator.transform(Wrapper.new('nil').compile))
-  end
-
-  test "double-braced args are evaluated in context" do
-    wrapper = Wrapper.new('foo', "{{xyz}}", "{{zyx}}", bar: "baz")
-    assert_equal '%Q(#{foo(xyz, zyx, bar: "baz")})', Interpolator.transform(wrapper.compile)
-  end
-
-  test "initializer block is preserved in compile" do
-    wrapper = Wrapper.new('foo') { whatever }
-    assert_equal '%Q(#{foo { whatever }})', Interpolator.transform(wrapper.compile)
-    wrapper = Wrapper.new('foo', 'bar') { whatever }
-    assert_equal '%Q(#{foo("bar") { whatever }})', Interpolator.transform(wrapper.compile)
-  end
-
-  test "lambda option values are evaluated in context" do
-    wrapper = Wrapper.new('foo', bar: -> { something })
-    assert_equal '%Q(#{foo(bar: (-> { something }).call)})', Interpolator.transform(wrapper.compile)
-  end
-
-end

data/test/markup/yielder_test.rb

@@ -1,9 +0,0 @@
-require 'test_helper'
-
-class YielderTest < ActiveSupport::TestCase
-
-  test "yielder preserves symbol args" do
-    assert_equal 'yield(:foo)', ExpressTemplates::Markup::Yielder.new(:foo).compile
-  end
-
-end