express_admin 1.2.1 → 1.3.0

data/vendor/gems/express_templates/test/components/capabilities/resourceful_test.rb

@@ -6,7 +6,7 @@ module AdminModule
   class SmartThing
     include ExpressTemplates::Components::Capabilities::Resourceful
 
-    attr_accessor :virtual_path
+    attr_accessor :virtual_path, :config
 
     def initialize(virtual_path, config = {})
       @virtual_path = virtual_path
@@ -14,8 +14,8 @@ module AdminModule
       @args = [self]
     end
 
-    def template
-      self
+    def template_virtual_path
+      @virtual_path
     end
   end
 end

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

@@ -4,40 +4,46 @@ class ConfigurableTest < ActiveSupport::TestCase
 
   ETC = ExpressTemplates::Components
 
-  class ConfigurableComponent < ETC::Base
-    include ETC::Capabilities::Configurable
-    emits -> {
-      div.bar(my[:id])
-    }
-  end
-
-  test "a configurable component accepts an id argument" do
-    assert :foo, ConfigurableComponent.new(:foo).my[:id]
+  class ConfigurableComponent < ETC::Configurable
+    def markup
+      div(id: my[:id], class: 'bar')
+    end
   end
 
   test "renders id argument as dom id" do
-    compiled_src = ConfigurableComponent.new(:foo).compile
-    assert '<div id="foo" class="bar" />', compiled_src
+    compiled_src = ExpressTemplates.render(self) { configurable_component(:foo) }
+    assert_equal "<div id=\"foo\" class=\"bar\"></div>\n", compiled_src
   end
 
-  class ConfigurableContainerComponent < ETC::Base
-    include ETC::Capabilities::Configurable
-    include ETC::Capabilities::Parenting
+  class ConfigurableContainerComponent < ETC::Configurable
 
     # make sure a helper can take arguments
-    helper(:name) {|name| name.to_s }
+    # helper(:name) {|name| name.to_s }
+    def name(name)
+      name.to_s
+    end
 
-    emits -> {
-      div(my[:id]) {
+    def markup &block
+      div(id: my[:id]) {
         h1 { name(my[:id]) }
-        _yield
+        yield(block) if block
       }
-    }
+    end
+  end
+
+  def assigns
+    {}
   end
 
   test "a configurable component may have also be a container" do
-    html = ExpressTemplates.render { configurable_container_component(:foo) { p "bar" }}
-    assert_equal '<div id="foo"><h1>foo</h1><p>bar</p></div>', html
+    html = ExpressTemplates.render(self) { configurable_container_component(:foo) { |c| para 'bar'} }
+    expected = <<-HTML
+<div id=\"foo\">
+  <h1>foo</h1>
+  <p>bar</p>
+</div>
+HTML
+    assert_equal "<div id=\"foo\">\n  <h1>foo</h1>\n  <p>bar</p>\n</div>\n", html
   end
 
 end

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

@@ -6,47 +6,87 @@ class BasicFieldsTest < ActiveSupport::TestCase
                     datetime_local number range
                     search telephone time url week)
 
-  test "text requires parent" do
-    fragment = -> {
-      text :name
-    }
-    assert_raises(RuntimeError) {
-      ExpressTemplates.compile(&fragment)
-    }
+  def assigns
+    {resource: resource}
+  end
+
+  def field_type_map
+    Hash[BASIC_FIELDS.map {|f| [f, f]}].merge(
+      {'phone'          => 'tel',
+       'telephone'          => 'tel',
+       'datetime_local' => 'datetime-local' })
+  end
+
+  def label_html
+    '<label for="foo_bar">Bar</label>'
   end
 
   test "all fields work" do
     BASIC_FIELDS.each do |type|
-      fragment = -> {
+      fragment = -> (ctx) {
         express_form(:foo) {
           send(type, :bar)
         }
       }
-      assert_match '#{label_tag("foo_bar", "Bar")', ExpressTemplates.compile(&fragment)
-      assert_match "#{type}_field(:foo, :bar)", ExpressTemplates.compile(&fragment)
+      html = arbre(&fragment)
+      assert_match label_html, html
+      assert_match(/input.*type="#{field_type_map[type]}"/, html)
+      # assert_match "#{type}_field(:foo, :bar, {})", arbre(&fragment)
+    end
+  end
+
+  test "passing html options to fields work" do
+    options = {class: 'form-field'}
+    BASIC_FIELDS.each do |type|
+      html = arbre {
+        express_form(:foo) {
+          send(type, :bar, options)
+        }
+      }
+      assert_match label_html, html
+      assert_match /input.*type="#{field_type_map[type]}"/, html
+      assert_match /input.*class="form-field"/, html
     end
   end
 
   test "textarea uses rails text_area helper" do
-    fragment = -> {
+    html = arbre {
       express_form(:foo) {
         textarea :bar
       }
     }
-    assert_match '#{label_tag("foo_bar", "Bar")', ExpressTemplates.compile(&fragment)
-    assert_match "text_area(:foo, :bar)", ExpressTemplates.compile(&fragment)
+    assert_match label_html, html
+    assert_match /<textarea name="foo\[bar\]" id="foo_bar"><\/textarea>/, html.gsub("\n", '')
   end
 
+  test "textarea passes additional html options to rails helper" do
+    html = arbre {
+      express_form(:foo) {
+        textarea :bar, rows: 5, class: 'tinymce form-field'
+      }
+    }
+    assert_match label_html, html
+    assert_match /<textarea rows="5" class="tinymce form-field" name="foo\[bar\]" id="foo_bar"><\/textarea>/, html.gsub("\n", '') 
+  end
 
   test "hidden uses rails hidden_tag helper" do
-    fragment = -> {
+    html = arbre {
       express_form(:foo) {
         hidden :bar
       }
     }
-    assert_no_match '#{label_tag("foo_bar", "Bar")', ExpressTemplates.compile(&fragment)
-    assert_match "hidden_field(:foo, :bar)", ExpressTemplates.compile(&fragment)
+    assert_no_match label_html, html
+    assert_match '<input type="hidden"', html
   end
 
-end
+  test "hidden field passes additional html options to rails helper" do
+    html = arbre {
+      express_form(:foo) {
+        hidden :bar, class: 'hidden form-field', value: 'ninja'
+      }
+    }
+    assert_no_match label_html, html
+    assert_match /<input class="hidden form-field" value="ninja" type="hidden" name="foo\[bar\]" id="foo_bar"/, html
+  end
 
+end

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

@@ -1,43 +1,37 @@
 require 'test_helper'
 
 class CheckboxTest < ActiveSupport::TestCase
-
-  test "Checkbox requires a parent form" do
-    fragment = -> {
-      checkbox :permission_granted
-    }
-    assert_raises(RuntimeError) {
-      ExpressTemplates.compile(&fragment)
-    }
+  def assigns
+    {resource: resource}
   end
 
   test "checkbox places the label before the input" do
-    fragment = -> {
+    html = arbre {
       express_form(:account) {
         checkbox :eula
       }
     }
-    compiled = ExpressTemplates.compile(&fragment)
-    label_helper = '#{label_tag("account_eula", "Eula")}'
-    field_helper = '#{check_box(:account, :eula, {}, "1", "0")}'
-    assert_match label_helper, compiled
-    assert_match field_helper, compiled
-    label_idx = compiled.index(label_helper)
-    field_idx = compiled.index(field_helper)
+    label = '<label for="account_eula"'
+    field = 'input type="checkbox" value="1" name="account\[eula\]"'
+    assert_match /#{label}/, html
+    assert_match /#{field}/, html
+    label_idx = html.index(label)
+    field_idx = html.index(field.gsub('\\', ''))
     assert (field_idx > label_idx), "label must come first"
   end
 
   test "checkbox respects label_after: true " do
-    fragment = -> {
+    html = arbre {
       express_form(:account) {
         checkbox :eula, label_after: true
       }
     }
-    compiled = ExpressTemplates.compile(&fragment)
-    label_helper = '#{label_tag("account_eula", "Eula")}'
-    field_helper = '#{check_box(:account, :eula, {}, "1", "0")}'
-    label_idx = compiled.index(label_helper)
-    field_idx = compiled.index(field_helper)
+    label = '<label for="account_eula"'
+    field = 'input type="checkbox" value="1" name="account\[eula\]"'
+    assert_match /#{label}/, html
+    assert_match /#{field}/, html
+    label_idx = html.index(label)
+    field_idx = html.index(field.gsub('\\', ''))
     assert (field_idx < label_idx), "label must come after when label_after: true"
   end
 

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

@@ -1,108 +1,55 @@
 require 'test_helper'
 require 'ostruct'
 
-class ExpressFormTest < ActiveSupport::TestCase
-  class Context
-    def initialize(resource)
-      @resource = resource
-    end
+  class Foo
+    def self.columns ; [] ; end
   end
 
-  def resource
-    OpenStruct.new(
-      id: 1,
-      name: 'Foo',
-      body: 'Hello world',
-      email: 'some@email.com',
-      phone: '123123123',
-      url: 'http://someurl.com',
-      number: 123,
-      dropdown: 'yes',
-      gender: 'Male'
-    )
+class ExpressFormTest < ActiveSupport::TestCase
+
+  def assigns
+    {resource: resource}
   end
 
-  def simplest_form(resource)
-    ctx = Context.new(resource)
-    fragment = -> {
+  def simplest_form
+    arbre {
       express_form(:resource) {
         submit value: 'Save it!'
       }
     }
-    return ctx, fragment
-  end
-
-  def express_form
-    "ExpressTemplates::Components::Forms::ExpressForm".constantize
-  end
-
-  test "express_form component exists" do
-    assert express_form
-  end
-
-  def compile_simplest_form
-    ctx, fragment = simplest_form(resource)
-    ExpressTemplates.compile(&fragment)
   end
 
   test "simplest form renders" do
-    assert compile_simplest_form
+    assert simplest_form
   end
 
   test "simplest form contains form tag" do
-    assert_match "<form", compile_simplest_form
-  end
-
-  test "simplest form contains rails form helpers" do
-    compiled_src = compile_simplest_form
-    assert_match "utf8_enforcer_tag", compiled_src
-    assert_match "method_tag(", compiled_src
-    assert_match "token_tag", compiled_src
-  end
-
-  test "simplest_form contains submit" do
-    assert_match 'submit_tag', compile_simplest_form
+    assert_match "<form", simplest_form
   end
 
-  test "simplest_form adopts children (submit has reference to parent)" do
-    ctx, fragment = simplest_form(resource)
-    expanded_nodes = ExpressTemplates::Expander.new(nil).expand(fragment.source_body)
-    assert_instance_of ExpressTemplates::Components::Forms::ExpressForm,
-                       expanded_nodes.first.children.last.parent
+  test "express_form contents are inside the form" do
+    assert_match /<form.*submit.*\/form>/, simplest_form.gsub("\n",'')
   end
 
-  test "#form_action uses url helpers" do
-    assert_equal "{{@foo.try(:persisted?) ? foo_path(@foo) : foos_path}}", express_form.new(:foo).form_action
+  test "simplest form contains rails form helpers" do
+    compiled_src = simplest_form
+    assert_match "input name=\"utf8\" type=\"hidden\"", compiled_src
+    assert_match "input type=\"hidden\" name=\"_method\"", compiled_src
+    assert_match "name=\"authenticity_token\" value=\"AUTH_TOKEN\"", compiled_src
+    assert_match /<form.*authenticity_token.*\/form>/, compiled_src.gsub("\n",'')
   end
 
-  test "#form_action uses correct path helper for update/patch" do
-    assert_equal "{{@foo.try(:persisted?) ? foo_path(@foo) : foos_path}}", express_form.new(:foo, method: :put).form_action
+  test "simplest_form contains submit" do
+    assert_match '<input type="submit" name="commit" value="Save" />', simplest_form
   end
 
   test "simplest_form uses form_action for the action" do
-    form_open_tag = compile_simplest_form.match(/<form[^>]*>/)[0]
-    assert_match 'action=\"#{@resource.try(:persisted?) ? resource_path(@resource) : resources_path}\"', form_open_tag
+    form_open_tag = simplest_form.match(/<form[^>]*>/)[0]
+    assert_match 'action="/resources"', form_open_tag
   end
 
   test "express_form default method is POST" do
-    form_open_tag = compile_simplest_form.match(/<form[^>]*>/)[0]
-    assert_match 'method=\"POST\"', form_open_tag
+    assert_match 'method="POST"', simplest_form
   end
 
-  test "express_form accepts :resource_name for removing namespace" do
-    fragment = -> {
-      express_form(:admin_foo, resource_name: 'foo') {
-        submit "Save!"
-      }
-    }
-    expanded_nodes = ExpressTemplates::Expander.new(nil).expand(fragment.source_body)
-    assert_equal 'foo', expanded_nodes.first.resource_name
-  end
-
-  # test "express_form has a namespace option with nil default" do
-  #   form = ExpressTemplates::Components::Forms::ExpressForm
-  #   assert_nil form.new(:person).namespace
-  #   assert_equal 'express_engine', form.new(:person, namespace: 'express_engine').namespace
-  # end
-
 end

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

@@ -2,17 +2,20 @@ require 'test_helper'
 
 class RadioTest < ActiveSupport::TestCase
 
+  def assigns
+    {resource: resource}
+  end
+
   test "radio requires a parent component" do
-    fragment = -> {
-      radio :preferred_email_format, ['HTML', 'Text']
-    }
     assert_raises(RuntimeError) {
-      ExpressTemplates.compile(&fragment)
+      html = arbre {
+        radio :preferred_email_format, ['HTML', 'Text']
+      }
     }
   end
 
   def radio_with_array_options
-    fragment = -> {
+    html = arbre {
       express_form(:person) {
         radio :preferred_email_format, ['HTML', 'Text']
       }
@@ -20,18 +23,17 @@ class RadioTest < ActiveSupport::TestCase
   end
 
   test "radio has correct label field name and text" do
-    assert_match '#{label_tag("person_preferred_email_format", "Preferred Email Format")}',
-                  ExpressTemplates.compile(&radio_with_array_options)
+    assert_match /<label for="person_preferred_email_format"/,
+                  radio_with_array_options
   end
 
   test "radio options present with class 'radio'" do
-    compiled = ExpressTemplates.compile(&radio_with_array_options)
-    assert_match 'radio_button(:person, :preferred_email_format, "Text", class: "radio"', compiled
-    assert_match '_format, "HTML", class: "radio"', compiled
+    assert_match /<input.*class="radio"/,
+                 radio_with_array_options
   end
 
   def radio_with_hash_options
-    fragment = -> {
+    html = arbre {
       express_form(:person) {
         radio :subscribed, {1 => 'Yes', 0 => 'No'}, wrapper_class: 'my-wrapper'
       }
@@ -39,34 +41,36 @@ class RadioTest < ActiveSupport::TestCase
   end
 
   test "radio options may be specified with a hash" do
-    compiled = ExpressTemplates.compile(&radio_with_hash_options)
-    assert_match '<label class=\"my-wrapper\">', compiled
-    assert_match 'radio_button(:person, :subscribed, 0, class: "radio"', compiled
-    assert_match 'radio_button(:person, :subscribed, 1, class: "radio"', compiled
+    compiled = radio_with_hash_options
+    assert_match '<label class="my-wrapper">', compiled
+    assert_match 'input class="radio" type="radio" value="0" name="person[subscribed]" id="person_subscribed_0" />No', compiled
+    assert_match 'input class="radio" type="radio" value="1" name="person[subscribed]" id="person_subscribed_1" />Yes', compiled
   end
 
   test "radio throws error if given improper options" do
-    fragment = -> {
-      express_form(:person) {
-        radio :subscribed, "Garbage options"
-      }
-    }
     assert_raises(RuntimeError) {
-      ExpressTemplates.compile(&fragment)
+      html = arbre {
+        express_form(:person) {
+          radio :subscribed, "Garbage options"
+        }
+      }
     }
   end
 
   def radio_with_options_omitted
-    fragment = -> {
+    html = arbre {
       express_form(:employee) {
         radio :department_id
       }
     }
   end
 
-  class ::Department
-    def self.columns
-      [OpenStruct.new(name: 'id'), OpenStruct.new(name: 'name')]
+  class ::Department < ::Gender
+    def self.order(*)
+      all
+    end
+    def self.all
+      return [new(1, 'Accounting'), new(2, 'Marketing')]
     end
   end
   class ::Employee
@@ -84,8 +88,8 @@ class RadioTest < ActiveSupport::TestCase
   end
 
   test "radio options from collection when options omitted" do
-    assert_match 'collection_radio_buttons(:employee, :department_id, Department.all.select(:id, :name).order(:name), :id, :name, {}, {}',
-                  ExpressTemplates.compile(&radio_with_options_omitted)
+    assert_match /input type="radio" value="1" name="employee\[department_id\]" id="employee_department_id_1"/,
+                  radio_with_options_omitted
   end
 
   # test "radio supports html options"