RubyGems - express_admin - Versions diffs - 1.1.0 → 1.2.0 - Mend

express_admin 1.1.0 → 1.2.0

Files changed (397) hide show

data/vendor/gems/express_templates/test/express_templates_test.rb ADDED Viewed

@@ -0,0 +1,19 @@
+require 'test_helper'
+class ExpressTemplatesTest < ActiveSupport::TestCase
+  test "we have a module" do
+    assert_kind_of Module, ExpressTemplates
+  end
+  test "ExpressTemplates.render renders a template" do
+    result = ExpressTemplates.render(self) do
+      ul {
+        li 'one'
+        li 'two'
+        li 'three'
+      }
+    end
+    assert_equal "<ul><li>one</li><li>two</li><li>three</li></ul>", result
+  end
+end

data/vendor/gems/express_templates/test/handler_test.rb ADDED Viewed

@@ -0,0 +1,122 @@
+require 'test_helper'
+class HandlerTest < ActiveSupport::TestCase
+  GARAHandler = ExpressTemplates::Template::Handler.new
+  DEFAULT_DOCTYPE = "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\" \"http://www.w3.org/TR/REC-html40/loose.dtd\">"
+  A_LINK = %Q(<a href="#">link</a>)
+  class LookupContext
+    def disable_cache
+      yield
+    end
+    def find_template(*args)
+    end
+    attr_accessor :formats
+  end
+  class Context
+    include ActionView::Context
+    include ActionView::Helpers::TagHelper
+    def initialize(*args)
+      @output_buffer = "original"
+      @virtual_path = nil
+    end
+    def lookup_context
+      @lookup_context ||= LookupContext.new
+    end
+    def concat(string)
+      @output_buffer << string
+    end
+    def capture(&block)
+      block.call
+    end
+    def link_helper
+      A_LINK
+    end
+  end
+  def new_template(body = " h1 'Hello' ", details = { format: :html })
+    ActionView::Template.new(body, "hello template", details.fetch(:handler) { GARAHandler }, {:virtual_path => "hello"}.merge!(details))
+  end
+  def render(locals = {})
+    output = @template.render(@context, locals)
+    output
+  end
+  def with_doctype(body, alt_doctype = nil)
+    "#{alt_doctype||DEFAULT_DOCTYPE}\n#{body}"
+  end
+  def setup
+    controller = Object.new
+    class << controller
+      def view_context_class ; Context ; end
+    end
+    @context = Context.new(nil, {}, controller)
+  end
+  test "our handler is registered" do
+    handler = ActionView::Template.registered_template_handler("et")
+    assert_equal ExpressTemplates::Template::Handler, handler
+  end
+  test "html generates <h1>Hello</h1> by default" do
+    @template = new_template
+    result = render
+    assert_equal "<h1>Hello</h1>", result
+  end
+  test "nesting elements with ruby block structure" do
+    @template = new_template("ul { li 'one' ; li 'two' ; li 'three' }")
+    assert_equal "<ul><li>one</li><li>two</li><li>three</li></ul>", render
+  end
+  test "class names" do
+    @template = new_template("p.whatever.another 'Lorum Ipsum' ")
+    assert_equal "<p class=\"whatever another\">Lorum Ipsum</p>", render
+  end
+  test "string in block works" do
+    @template = new_template "h1 { 'foo' } "
+    assert_equal "<h1>foo</h1>", render
+  end
+  # test "real document has doctype and newline" do
+  #   @template = new_template("html { body { h1 \"hello\" } }")
+  #   assert_equal with_doctype("<html xmlns=\"http://www.w3.org/1999/xhtml\">\n  <body>\n    <h1>hello</h1>\n  </body>\n</html>\n"), render
+  # end
+  test "other attributes" do
+    @template = new_template("p('Lorum Ipsum', style: 'align: right;')")
+    assert_equal "<p style=\"align: right;\">Lorum Ipsum</p>", render
+  end
+  test "locals work" do
+    @template = new_template "h1 { my_title }"
+    @template.locals = [:my_title]
+    assert_equal "<h1>Foo</h1>", render(my_title: 'Foo')
+  end
+  test "helpers returning html when alone in a block" do
+    @template = new_template("li { link_helper } ")
+    assert_equal "<li>#{A_LINK}</li>", render
+  end
+  test "helpers returning html work in sequence within a block" do
+    @template = new_template("li { link_helper ; link_helper } ")
+    assert_equal "<li>#{A_LINK}#{A_LINK}</li>", render
+  end
+end

data/vendor/gems/express_templates/test/indenter_test.rb ADDED Viewed

@@ -0,0 +1,27 @@
+require 'test_helper'
+class IndenterTest < ActiveSupport::TestCase
+  Indenter = ExpressTemplates::Indenter
+  test ".for(:name) takes a block receiving whitespace" do
+    Indenter.for(:foo) do
+      assert_equal "\n  ", Indenter.for(:foo) { |indent, indent_with_newline| indent_with_newline }
+      assert_equal "  ", Indenter.for(:foo) { |indent, indent_with_newline| indent }
+    end
+  end
+  test "nesting blocks increases whitespace accordingly" do
+    nested_whitespace = Indenter.for(:foo) do |ws1|
+      Indenter.for(:foo) do |ws2|
+        ws2
+      end
+    end
+    assert_equal "  ", nested_whitespace
+  end
+  test ".for(:name) returns current indent without newline when block is not given" do
+    assert_equal "", Indenter.for(:foo) { |_| Indenter.for(:foo) }
+  end
+end

data/vendor/gems/express_templates/test/interpolator_test.rb ADDED Viewed

@@ -0,0 +1,80 @@
+require 'test_helper'
+require 'express_templates/interpolator'
+require 'parslet/convenience'
+class InterpolatorTest < ActiveSupport::TestCase
+  def parse(s)
+    parser = ExpressTemplates::Interpolator.new
+    parsed = parser.parse_with_debug(s)
+    pp parsed if ENV['DEBUG'].eql?('true')
+    parsed
+  end
+  def transform(s)
+    trans = ExpressTemplates::Transformer.new
+    trans.apply(parse(s)).flatten.join
+  end
+  test "simplest expression parses" do
+    tree = parse("{{something}}")
+    expected = [{:interpolation=>{:expression=>[{:text=>"something"}]}}]
+    assert_equal expected, tree
+  end
+  test "simple expression with surrounding text parses" do
+    tree = parse('whatever {{something}} something else')
+    expected = [{:text=>"whatever "},
+                {:interpolation=>{:expression=>[{:text=>"something"}]}},
+                {:text=>" something else"}]
+    assert_equal expected, tree
+  end
+  test "nested without outer text parses" do
+    tree = parse('{{some {{thing}} foo}}')
+    expected = [{:interpolation=>
+                {:expression=>
+                  [{:text=>"some "},
+                   {:interpolation=>{:expression=>[{:text=>"thing"}]}},
+                   {:text=>" foo"}]}}]
+    assert_equal expected, tree
+  end
+  test "nested with outer text parses" do
+    tree = parse('a lot of {{something {{good}}}}')
+    expected = [{:text=>"a lot of "},
+                {:interpolation=>
+                  {:expression=>
+                    [{:text=>"something "},
+                     {:interpolation=>{:expression=>[{:text=>"good"}]}}]}}]
+    assert_equal expected, tree
+  end
+  test 'nested with multiple nested expressions parses' do
+    tree = parse(%q(%Q({{foo("{{xyz}}", "{{zyx}}", bar: "baz")}})))
+    expected = [{:text=>"%Q("},
+                {:interpolation=>
+                  {:expression=>
+                    [{:text=>"foo(\""},
+                     {:interpolation=>{:expression=>[{:text=>"xyz"}]}},
+                     {:text=>"\", \""},
+                     {:interpolation=>{:expression=>[{:text=>"zyx"}]}},
+                     {:text=>"\", bar: \"baz\")"}]}},
+                {:text=>")"}]
+    assert_equal expected, tree
+  end
+  test '"{{something}}" transforms to "#{something}"' do
+    assert_equal '#{something}', transform("{{something}}")
+  end
+  test '"{{some {{thing}} foo}}" transforms to "#{some #{thing} foo}"' do
+    assert_equal '#{some #{thing} foo}', transform("{{some {{thing}} foo}}")
+  end
+  test %('a lot of {{something "{{good}}"}}' transforms) do
+    assert_equal 'a lot of #{something "#{good}"}', transform('a lot of {{something "{{good}}"}}')
+  end
+end

data/vendor/gems/express_templates/test/markup/tag_test.rb ADDED Viewed

@@ -0,0 +1,149 @@
+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/vendor/gems/express_templates/test/markup/wrapper_test.rb ADDED Viewed

@@ -0,0 +1,42 @@
+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/vendor/gems/express_templates/test/markup/yielder_test.rb ADDED Viewed

@@ -0,0 +1,9 @@
+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