express_templates 0.5.0 → 0.7.0

data/lib/express_templates/markup/wrapper.rb

@@ -1,94 +0,0 @@
-module ExpressTemplates
-  module Markup
-    # wrap locals and helpers for evaluation during render
-    class Wrapper
-
-      attr_accessor :name, :args
-
-      def initialize(name, *args, &block)
-        @name = name
-        @args = args
-        @block_src = block ? block.source : nil
-      end
-
-      def compile
-        # insure nils do not blow up view
-        %Q(%Q({{#{_compile}}}))
-      end
-
-      def to_template
-        _compile
-      end
-
-      def children
-        []
-      end
-
-      private
-        def _compile
-          string = "#{name}"
-
-          if !@args.empty?
-
-            args_string = args.slice(0..-2).map do |arg|
-              if arg.respond_to?(:gsub) && arg.match(/^\{\{(.*)\}\}$/)
-                # strip double braces because otherwise these will be converted
-                # to "#{arg}" during final interpolation which is generally not
-                # the intention for arguments to helpers as these are ruby expressions
-                # not necessarily returning strings
-                $1
-              else
-                arg.inspect # 'value' or :value or ['a', 'b', 'c'] or {:key => 'value'}
-              end
-            end.join(', ')
-
-            last_arg = ''
-            if args.last.is_a?(Hash) # expand a hash
-              last_arg = _convert_hash_to_argument_string(args.last)
-            else
-              last_arg = args.last.inspect
-            end
-            args_string << (args_string.empty? ? last_arg : ", #{last_arg}")
-            string << "(#{args_string})"
-          end
-
-          if @block_src
-            string << " #{@block_src}"
-          end
-
-          return string
-        end
-
-        def _convert_hash_to_argument_string(hash)
-          use_hashrockets = hash.keys.any? {|key| key.to_s.match /-/}
-          unless hash.empty?
-            return hash.map do |key, value|
-              s = if use_hashrockets
-                if key.to_s.match /-/
-                  "'#{key}' => "
-                else
-                  ":#{key} => "
-                end
-              else
-                "#{key}: "
-              end
-
-              case
-              when value.is_a?(String)
-                s << '"'+value+'"'
-              when value.is_a?(Hash)
-                s << value.inspect
-              when value.is_a?(Proc)
-                s << "(#{value.source}).call"
-              else
-                s << value.inspect  # immediate values 1, 2.0, true etc
-              end
-              s
-            end.join(", ")
-          else
-            "{}" # empty hash
-          end
-        end
-    end
-  end
-end

data/lib/express_templates/markup/yielder.rb

@@ -1,21 +0,0 @@
-module ExpressTemplates
-  module Markup
-    class Yielder
-      def initialize(*args)
-        @arg = args.first
-      end
-
-      def compile
-        if @arg
-          "yield(#{@arg.inspect})" # usually a symbol but may be string
-        else
-          "yield"
-        end
-      end
-
-      def to_template
-        compile
-      end
-    end
-  end
-end

data/lib/express_templates/markup.rb

@@ -1,9 +0,0 @@
-module ExpressTemplates
-  module Markup
-  end
-end
-
-require 'express_templates/markup/tag'
-require 'express_templates/markup/html_tag'
-require 'express_templates/markup/wrapper'
-require 'express_templates/markup/yielder'

data/test/components/column_test.rb

@@ -1,11 +0,0 @@
-require 'test_helper'
-
-class ColumnTest < ActiveSupport::TestCase
-
-  ETC = ExpressTemplates::Components
-
-  test "a column is configurable" do
-    assert ETC::Column.ancestors.include?(ETC::Capabilities::Configurable)
-  end
-
-end

data/test/components/conditionality_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-class ConditionalityTest < ActiveSupport::TestCase
-
-  def empty_title_context
-    ctx = Object.new
-    ctx.instance_variable_set(:@title, '')
-    ctx
-  end
-
-  def present_title_context
-    ctx = Object.new
-    ctx.instance_variable_set(:@title, 'Something')
-    ctx
-  end
-
-  class ConditionalRenderer < ExpressTemplates::Components::Base
-    include ExpressTemplates::Components::Capabilities::Conditionality
-
-      emits -> {
-        h1 "{{@title}}"
-      }
-
-      only_if -> { !@title.empty? }
-  end
-
-  test "when supplied condition is false, renders empty string" do
-    compiled_src = ConditionalRenderer.new.compile
-    assert_equal '', empty_title_context.instance_eval(compiled_src)
-  end
-
-  test "when supplied condition is true, renders the component" do
-    compiled_src = Interpolator.transform(ConditionalRenderer.new.compile)
-    assert_equal '<h1>Something</h1>', present_title_context.instance_eval(compiled_src)
-  end
-
-end

data/test/components/container_test.rb

@@ -1,66 +0,0 @@
-require 'test_helper'
-require 'minitest/mock'
-
-class ContainerTest < ActiveSupport::TestCase
-
-  ETC = ExpressTemplates::Components
-
-  def any_container
-    Class.new(ETC::Container)
-  end
-
-  test "a Container is a Component" do
-    assert_kind_of ETC::Base, any_container.new
-  end
-
-  test "a container has children but initially has none" do
-    assert any_container.new.respond_to?(:children)
-    assert_equal [], any_container.new.children
-  end
-
-  def mock_children
-    child1, child2 = Minitest::Mock.new, Minitest::Mock.new
-    child1.expect(:compile, '"one"')
-    child2.expect(:compile, '"two"')
-    child1.expect(:kind_of?, false, [ExpressTemplates::Components::Capabilities::Adoptable])
-    child2.expect(:kind_of?, false, [ExpressTemplates::Components::Capabilities::Adoptable])
-    return child1, child2
-  end
-
-  class TestContainer < ETC::Container
-    emits -> { p { _yield } }
-  end
-
-  test "Container#compile calls #compile on its children" do
-    container = TestContainer.new
-    child1, child2 = mock_children
-    container.children = [child1, child2]
-    container.compile
-    child1.verify
-    child2.verify
-  end
-
-  test "renders children in place of _yield" do
-    container = TestContainer.new
-    child1, child2 = mock_children
-    container.children = [child1, child2]
-
-    assert_equal "<p>onetwo</p>", eval(container.compile)
-  end
-
-  class Context
-    def a_helper
-      "foo"
-    end
-  end
-
-  test "children with interpolations" do
-    markup = ExpressTemplates.render(Context.new) do
-      row {
-        p %q(Should say: {{a_helper}}.)
-      }
-    end
-    assert_equal "<div class=\"row\"><p>Should say: foo.</p></div>", markup
-  end
-
-end

data/test/components/content_for_test.rb

@@ -1,60 +0,0 @@
-require 'test_helper'
-
-class ContentForTest < ActiveSupport::TestCase
-
-  class Context
-    def content_for(label, markup=nil, &block)
-      @blocks ||= {}
-      if block || markup
-        @blocks[label] = block ? block.call : markup
-        nil
-      else
-        @blocks[label]
-      end
-    end
-  end
-
-  test "content_for accepts a block of express template" do
-    fragment = -> {
-      content_for(:whatever) { h1 'hello' }
-    }
-    context = Context.new
-    markup = ExpressTemplates.render(context, &fragment)
-    assert_equal %Q(<h1>hello</h1>), context.content_for(:whatever)
-  end
-
-  test "content_for accepts a second argument which contains markup" do
-    fragment = -> {
-      content_for :title, "Foo"
-    }
-    context = Context.new
-    markup = ExpressTemplates.render(context, &fragment)
-    assert_equal 'Foo', context.content_for(:title)
-  end
-
-  test "content_for without a body returns the markup" do
-    fragment = -> {
-      content_for :title
-    }
-    context = Context.new
-    context.content_for :title, "Foo"
-    markup = ExpressTemplates.render(context, &fragment)
-    assert_equal 'Foo', markup
-  end
-
-  test "content_for body is html_safe" do
-    arg_frag = -> {
-      content_for :title, "<h1>Foo</h1>"
-    }
-    context = Context.new
-    markup = ExpressTemplates.render(context, &arg_frag)
-    assert context.content_for(:title).html_safe?
-
-    block_frag = -> {
-      content_for(:title) { h1 "Foo" }
-    }
-    markup = ExpressTemplates.render(context, &block_frag)
-    assert context.content_for(:title).html_safe?
-  end
-
-end

data/test/components/iterating_test.rb

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

data/test/components/null_wrap_test.rb

@@ -1,28 +0,0 @@
-require 'test_helper'
-
-class NullWrapTest < ActiveSupport::TestCase
-
-  ETC = ExpressTemplates::Components
-
-  test "a NullWrap is a Container" do
-    assert ETC::NullWrap.ancestors.include?(ETC::Capabilities::Parenting)
-  end
-
-  test "null_wrap accepts a string contianing a ruby string def" do
-    compiled_src = ETC::NullWrap.new("%q(<p>whatever<p>)").compile
-    assert_equal '<p>whatever<p>', eval(compiled_src)
-  end
-
-  test "null_wrap wraps template code" do
-    fragment = -> {
-      null_wrap {
-        p {
-          "whatever"
-        }
-      }
-    }
-    assert_equal '<p>whatever</p>', eval(ExpressTemplates.compile(&fragment))
-  end
-
-
-end

data/test/components/row_test.rb

@@ -1,16 +0,0 @@
-require 'test_helper'
-
-class RowTest < ActiveSupport::TestCase
-
-  ETC = ExpressTemplates::Components
-
-  test "a row is configurable" do
-    assert ETC::Row.ancestors.include?(ETC::Capabilities::Configurable)
-  end
-
-  test "id is optional" do
-    compiled_src = ETC::Row.new(nil).compile
-    assert_equal '<div class="row"></div>', eval(compiled_src)
-  end
-
-end

data/test/components/table_for_test.rb

@@ -1,211 +0,0 @@
-require 'test_helper'
-require 'ostruct'
-
-class TableForTest < ActiveSupport::TestCase
-
-  class Context
-    def initialize(test_items)
-      @test_items = test_items
-    end
-  end
-
-  def test_items
-    [OpenStruct.new(id: 1, name: 'Foo', price: 1.23),
-     OpenStruct.new(id: 2, name: 'Bar', price: 5.49),
-     OpenStruct.new(id: 3, name: 'Baz', price: 99.97)]
-  end
-
-  EXAMPLE_COMPILED = -> {
-    ExpressTemplates::Components::TableFor.render_in(self) {
-"
-<table id=\"test_items\">
-  <thead>
-    <tr>
-      <th class=\"name\">Name</th>
-      <th class=\"price\">Price</th>
-    </tr>
-  </thead>
-
-  <tbody>"+(@test_items.each_with_index.map do |test_item, test_item_index|
-"
-    <tr id=\"test_item-#{test_item.id}\" class=\"test_item\">
-      <td class=\"name\">#{test_item.name}</td>
-      <td class=\"price\">#{(-> (price) { '$%0.2f' % price }).call(test_item.price)}</td>
-    </tr>
-"
-end).join+"  </tbody>
-</table>
-"
-}
-}
-
-  EXAMPLE_MARKUP = <<-HTML
-
-<table id="test_items">
-  <thead>
-    <tr>
-      <th class="name">Name</th>
-      <th class="price">Price</th>
-    </tr>
-  </thead>
-
-  <tbody>
-    <tr id="test_item-1" class="test_item">
-      <td class="name">Foo</td>
-      <td class="price">$1.23</td>
-    </tr>
-
-    <tr id="test_item-2" class="test_item">
-      <td class="name">Bar</td>
-      <td class="price">$5.49</td>
-    </tr>
-
-    <tr id="test_item-3" class="test_item">
-      <td class="name">Baz</td>
-      <td class="price">$99.97</td>
-    </tr>
-  </tbody>
-</table>
-  HTML
-
-
-  EXAMPLE_WITH_ACTIONS_COMPILED = -> {
-    ExpressTemplates::Components::TableFor.render_in(self) {
-"
-<table id=\"test_items\">
-  <thead>
-    <tr>
-      <th class=\"name\">Name</th>
-      <th class=\"price\">Price</th>
-      <th class=\"default_actions\">Actions</th>
-    </tr>
-  </thead>
-
-  <tbody>"+(@test_items.each_with_index.map do |test_item, test_item_index|
-"
-    <tr id=\"test_item-#{test_item.id}\" class=\"test_item\">
-      <td class=\"name\">#{test_item.name}</td>
-      <td class=\"price\">#{(-> (price) { '$%0.2f' % price }).call(test_item.price)}</td>
-      <td class=\"default_actions\">
-<a href='/test_items/#{test_item.id}'>Show</a>
-<a href='/test_items/#{test_item.id}/edit'>Edit</a>
-<a href='/test_items/#{test_item.id}' data-method='delete' data-confirm='Are you sure?'>Delete</a>
-      </td>
-    </tr>
-"
-end).join+"  </tbody>
-</table>
-"
-}
-}
-
-  EXAMPLE_WITH_ACTIONS_MARKUP = <<-HTML
-
-<table id="test_items">
-  <thead>
-    <tr>
-      <th class="name">Name</th>
-      <th class="price">Price</th>
-      <th class="default_actions">Actions</th>
-    </tr>
-  </thead>
-
-  <tbody>
-    <tr id="test_item-1" class="test_item">
-      <td class="name">Foo</td>
-      <td class="price">$1.23</td>
-      <td class="default_actions">
-<a href='/test_items/1'>Show</a>
-<a href='/test_items/1/edit'>Edit</a>
-<a href='/test_items/1' data-method='delete' data-confirm='Are you sure?'>Delete</a>
-      </td>
-    </tr>
-
-    <tr id="test_item-2" class="test_item">
-      <td class="name">Bar</td>
-      <td class="price">$5.49</td>
-      <td class="default_actions">
-<a href='/test_items/2'>Show</a>
-<a href='/test_items/2/edit'>Edit</a>
-<a href='/test_items/2' data-method='delete' data-confirm='Are you sure?'>Delete</a>
-      </td>
-    </tr>
-
-    <tr id="test_item-3" class="test_item">
-      <td class="name">Baz</td>
-      <td class="price">$99.97</td>
-      <td class="default_actions">
-<a href='/test_items/3'>Show</a>
-<a href='/test_items/3/edit'>Edit</a>
-<a href='/test_items/3' data-method='delete' data-confirm='Are you sure?'>Delete</a>
-      </td>
-    </tr>
-  </tbody>
-</table>
-  HTML
-
-  def simple_table(test_items)
-    ctx = Context.new(test_items)
-    fragment = -> {
-      table_for(:test_items) do |t|
-        t.column :name, header: "Name"
-        t.column :price, formatter: -> (price) { '$%0.2f' % price }
-      end
-    }
-    return ctx, fragment
-  end
-
-  def table_with_actions(test_items)
-    ctx = Context.new(test_items)
-    fragment = -> {
-      table_for(:test_items) do |t|
-        t.column :name
-        t.column :price, formatter: -> (price) { '$%0.2f' % price }
-        t.column :default_actions, header: "Actions", actions: [:show, :edit, :delete]
-      end
-    }
-    return ctx, fragment
-  end
-
-  def example_compiled_src
-    # necessary because the #source method is not perfect yet
-    # ideally we would have #source_body
-    EXAMPLE_COMPILED.source_body
-  end
-
-  def example_with_actions_compiled_src
-    EXAMPLE_WITH_ACTIONS_COMPILED.source_body
-  end
-
-  test "example view code evaluates to example markup" do
-    assert_equal EXAMPLE_MARKUP, Context.new(test_items).instance_eval(EXAMPLE_COMPILED.source_body)
-    assert_equal EXAMPLE_WITH_ACTIONS_MARKUP, Context.new(test_items).instance_eval(EXAMPLE_WITH_ACTIONS_COMPILED.source_body)
-  end
-
-  test "compiled source is legible and transparent" do
-    ExpressTemplates::Markup::Tag.formatted do
-      ctx, fragment = simple_table(test_items)
-      assert_equal example_compiled_src, ExpressTemplates.compile(&fragment)
-      actx, afragment = table_with_actions(test_items)
-      assert_equal example_with_actions_compiled_src, ExpressTemplates.compile(&afragment)
-    end
-  end
-
-  test "example compiled source renders the markup in the context" do
-    ctx, fragment = simple_table(test_items)
-    assert_equal EXAMPLE_MARKUP, ctx.instance_eval(example_compiled_src)
-
-    actx, afragment = table_with_actions(test_items)
-    assert_equal EXAMPLE_WITH_ACTIONS_MARKUP, actx.instance_eval(example_with_actions_compiled_src)
-  end
-
-  test "rendered component matches desired markup" do
-    ExpressTemplates::Markup::Tag.formatted do
-      ctx, fragment = simple_table(test_items)
-      assert_equal EXAMPLE_MARKUP, ExpressTemplates.render(ctx, &fragment)
-
-      actx, afragment = table_with_actions(test_items)
-      assert_equal EXAMPLE_WITH_ACTIONS_MARKUP, ExpressTemplates.render(actx, &afragment)
-    end
-  end
-end