express_admin 1.1.0 → 1.2.0

data/vendor/gems/express_templates/test/components/forms/select_test.rb

@@ -0,0 +1,146 @@
+require 'test_helper'
+require 'ostruct'
+class SelectTest < ActiveSupport::TestCase
+
+  test "select requires a parent component" do
+    fragment = -> {
+      select :gender, ['Male', 'Female'], selected: 'Male'
+    }
+    assert_raises(RuntimeError) {
+      ExpressTemplates.compile(&fragment)
+    }
+  end
+
+  test "select comes with a label" do
+    fragment = -> {
+      express_form(:person) {
+        select :gender
+      }
+    }
+    assert_match '#{label_tag("person_gender", "Gender")}', ExpressTemplates.compile(&fragment)
+  end
+
+  test "select uses options_for_select when values are specified" do
+    fragment = -> {
+      express_form(:person) {
+        select :gender, ['Male', 'Female'], selected: 'Male'
+      }
+    }
+    assert_match 'options_for_select(["Male", "Female"], "Male")', ExpressTemplates.compile(&fragment)
+  end
+
+  test "selected option is omitted selection is taken from model" do
+    fragment = -> {
+      express_form(:person) {
+        select :gender, ['Male', 'Female']
+      }
+    }
+    assert_match 'options_for_select(["Male", "Female"], @person.gender)', ExpressTemplates.compile(&fragment)
+  end
+
+  test "select generates options from data when options omitted" do
+    fragment = -> {
+      express_form(:person) {
+        select :city
+      }
+    }
+    assert_match 'options_for_select(@person.class.distinct(:city).pluck(:city), @person.city)', ExpressTemplates.compile(&fragment)
+  end
+
+  class ::Gender
+    def self.columns
+      [OpenStruct.new(name: 'id'), OpenStruct.new(name: 'name')]
+    end
+  end
+  class ::Tagging
+    def self.columns
+      [OpenStruct.new(name: 'id'), OpenStruct.new(name: 'name')]
+    end
+  end
+  class ::Person
+    def self.reflect_on_association(name)
+      if name.eql? :gender
+        dummy_belongs_to_association = Object.new
+        class << dummy_belongs_to_association
+          def macro ; :belongs_to ; end
+          def klass ; ::Gender ; end
+          def polymorphic? ; false ; end
+        end
+        return dummy_belongs_to_association
+      end
+      if name.eql? :taggings
+        dummy_has_many_through_association = Object.new
+        class << dummy_has_many_through_association
+          def macro ; :has_many ; end
+          def klass ; ::Tagging ; end
+          def options ; {:through => :peron_tags} ; end
+          def polymorphic? ; false ; end
+        end
+        return dummy_has_many_through_association
+      end
+    end
+  end
+
+  test "select uses options_from_collect... when field is relation" do
+    fragment = -> {
+      express_form(:person) {
+        select :gender
+      }
+    }
+
+    assert_match 'options_from_collection_for_select(Gender.all.select(:id, :name).order(:name), :id, :name, @person.gender)',
+                  ExpressTemplates.compile(&fragment)
+  end
+
+  test "select defaults to include_blank: true" do
+    fragment = -> {
+      express_form(:person) {
+        select :gender
+      }
+    }
+    assert_match 'include_blank: true', ExpressTemplates.compile(&fragment)
+  end
+
+
+  test "select defaults can be overridden" do
+    fragment = -> {
+      express_form(:person) {
+        select :gender, nil, include_blank: false
+      }
+    }
+    assert_no_match 'include_blank: true', ExpressTemplates.compile(&fragment)
+  end
+
+  test "select multiple: true if passed multiple true" do
+    fragment = -> {
+      express_form(:person) {
+        select :taggings, nil, include_blank: false, multiple: true
+      }
+    }
+    assert_match 'multiple: true', ExpressTemplates.compile(&fragment)
+  end
+
+  test "select multiple gets options from associated has_many_through collection" do
+    fragment = -> {
+      express_form(:person) {
+        select :taggings, nil, include_blank: false, multiple: true
+      }
+    }
+    assert_match 'tagging_ids', ExpressTemplates.compile(&fragment)
+    assert_match 'options_from_collection_for_select(Tagging.all.select(:id, :name).order(:name), :id, :name, @person.taggings.map(&:id))',
+                 ExpressTemplates.compile(&fragment)
+  end
+
+  test "select_collection uses collection_select" do
+    fragment = -> {
+      express_form(:person) {
+        select_collection :taggings
+      }
+    }
+    assert_match 'tagging_ids', ExpressTemplates.compile(&fragment)
+    assert_match 'collection_select("person", "tagging_ids", Tagging.all.select(:id, :name).order(:name), :id, :name, {:include_blank=>false, :selected=>@person.tagging_ids}, multiple: true)',
+                 ExpressTemplates.compile(&fragment)
+  end
+
+
+end

data/vendor/gems/express_templates/test/components/forms/submit_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+
+class SubmitTest < ActiveSupport::TestCase
+  test "submit takes string param for value" do
+    fragment = -> {
+      express_form(:stuff) {
+        submit "Save it!"
+      }
+    }
+    assert_match '#{submit_tag("Save it!", {})}', ExpressTemplates.compile(&fragment)
+  end
+end

data/vendor/gems/express_templates/test/components/iterating_test.rb

@@ -0,0 +1,127 @@
+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/vendor/gems/express_templates/test/components/null_wrap_test.rb

@@ -0,0 +1,28 @@
+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/vendor/gems/express_templates/test/components/row_test.rb

@@ -0,0 +1,16 @@
+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/vendor/gems/express_templates/test/components/table_for_test.rb

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