dry_crud 6.0.0 → 8.0.0

data/lib/generators/dry_crud/templates/test/helpers/dry_crud/form/builder_test.rb

@@ -1,5 +1,5 @@
-require 'test_helper'
-require 'support/crud_test_model'
+require "test_helper"
+require "support/crud_test_model"
 
 module DryCrud
   module Form
@@ -22,226 +22,226 @@ module DryCrud
         @form = DryCrud::Form::Builder.new(:entry, @entry, self, {})
       end
 
-      test 'input_field dispatches string attr to string_field' do
+      test "input_field dispatches string attr to string_field" do
         assert_equal form.with_addon(
           form.string_field(:name,
-                            required: 'required'),
-          '*'
+                            required: "required"),
+          "*"
         ),
                      form.input_field(:name)
         assert form.string_field(:name).html_safe?
       end
 
-      test 'input_field dispatches password attr to password_field' do
+      test "input_field dispatches password attr to password_field" do
         assert_equal form.password_field(:password),
                      form.input_field(:password)
         assert form.password_field(:name).html_safe?
       end
 
-      test 'input_field dispatches email attr to email_field' do
+      test "input_field dispatches email attr to email_field" do
         assert_equal form.email_field(:email),
                      form.input_field(:email)
         assert form.email_field(:name).html_safe?
       end
 
-      test 'input_field dispatches text attr to text_area' do
+      test "input_field dispatches text attr to text_area" do
         assert_equal form.text_area(:remarks),
                      form.input_field(:remarks)
         assert form.text_area(:remarks).html_safe?
       end
 
-      test 'input_field dispatches integer attr to integer_field' do
+      test "input_field dispatches integer attr to integer_field" do
         assert_equal form.integer_field(:children),
                      form.input_field(:children)
         assert form.integer_field(:children).html_safe?
       end
 
-      test 'input_field dispatches boolean attr to boolean_field' do
+      test "input_field dispatches boolean attr to boolean_field" do
         assert_equal form.boolean_field(:human),
                      form.input_field(:human)
         assert form.boolean_field(:human).html_safe?
       end
 
-      test 'input_field dispatches date attr to date_field' do
+      test "input_field dispatches date attr to date_field" do
         assert_equal form.date_field(:birthdate),
                      form.input_field(:birthdate)
         assert form.date_field(:birthdate).html_safe?
       end
 
-      test 'input_field dispatches belongs_to attr to select field' do
+      test "input_field dispatches belongs_to attr to select field" do
         assert_equal form.belongs_to_field(:companion_id),
                      form.input_field(:companion_id)
         assert form.belongs_to_field(:companion_id).html_safe?
       end
 
-      test 'input_field dispatches has_and_belongs_to_many attr to ' \
-           'select field' do
+      test "input_field dispatches has_and_belongs_to_many attr to " \
+           "select field" do
         assert_equal form.has_many_field(:other_ids),
                      form.input_field(:other_ids)
         assert form.has_many_field(:other_ids).html_safe?
       end
 
-      test 'input_field dispatches has_many attr to select field' do
+      test "input_field dispatches has_many attr to select field" do
         assert_equal form.has_many_field(:more_ids),
                      form.input_field(:more_ids)
         assert form.has_many_field(:more_ids).html_safe?
       end
 
-      test 'input_fields concats multiple fields' do
+      test "input_fields concats multiple fields" do
         result = form.labeled_input_fields(:name, :remarks, :children)
         assert result.html_safe?
-        assert result.include?(form.input_field(:name, required: 'required'))
+        assert result.include?(form.input_field(:name, required: "required"))
         assert result.include?(form.input_field(:remarks))
         assert result.include?(form.input_field(:children))
       end
 
-      test 'labeld_input_field adds required mark' do
+      test "labeld_input_field adds required mark" do
         result = form.labeled_input_field(:name)
-        assert result.include?('input-group-append')
+        assert result.include?("input-group-text")
         result = form.labeled_input_field(:remarks)
-        assert_not result.include?('input-group-append')
+        assert_not result.include?("input-group-text")
       end
 
-      test 'labeld_input_field adds help text' do
-        result = form.labeled_input_field(:name, help: 'Some Help')
-        assert result.include?(form.help_block('Some Help'))
-        assert result.include?('input-group-append')
+      test "labeld_input_field adds help text" do
+        result = form.labeled_input_field(:name, help: "Some Help")
+        assert result.include?(form.help_block("Some Help"))
+        assert result.include?("input-group-text")
       end
 
-      test 'belongs_to_field has all options by default' do
+      test "belongs_to_field has all options by default" do
         f = form.belongs_to_field(:companion_id)
-        assert_equal 7, f.scan('</option>').size
+        assert_equal 7, f.scan("</option>").size
       end
 
-      test 'belongs_to_field with :list option' do
+      test "belongs_to_field with :list option" do
         list = CrudTestModel.all
         f = form.belongs_to_field(:companion_id,
-                                  list: [list.first, list.second])
-        assert_equal 3, f.scan('</option>').size
+                                  list: [ list.first, list.second ])
+        assert_equal 3, f.scan("</option>").size
       end
 
-      test 'belongs_to_field with instance variable' do
+      test "belongs_to_field with instance variable" do
         list = CrudTestModel.all
-        @companions = [list.first, list.second]
+        @companions = [ list.first, list.second ]
         f = form.belongs_to_field(:companion_id)
-        assert_equal 3, f.scan('</option>').size
+        assert_equal 3, f.scan("</option>").size
       end
 
-      test 'belongs_to_field with empty list' do
+      test "belongs_to_field with empty list" do
         @companions = []
         f = form.belongs_to_field(:companion_id)
-        assert_match t('global.associations.none_available'), f
-        assert_equal 0, f.scan('</option>').size
+        assert_match t("global.associations.none_available"), f
+        assert_equal 0, f.scan("</option>").size
       end
 
-      test 'has_and_belongs_to_many_field has all options by default' do
+      test "has_and_belongs_to_many_field has all options by default" do
         f = form.has_many_field(:other_ids)
-        assert_equal 6, f.scan('</option>').size
+        assert_equal 6, f.scan("</option>").size
       end
 
-      test 'has_and_belongs_to_many_field with :list option' do
+      test "has_and_belongs_to_many_field with :list option" do
         list = OtherCrudTestModel.all
-        f = form.has_many_field(:other_ids, list: [list.first, list.second])
-        assert_equal 2, f.scan('</option>').size
+        f = form.has_many_field(:other_ids, list: [ list.first, list.second ])
+        assert_equal 2, f.scan("</option>").size
       end
 
-      test 'has_and_belongs_to_many_field with instance variable' do
+      test "has_and_belongs_to_many_field with instance variable" do
         list = OtherCrudTestModel.all
-        @others = [list.first, list.second]
+        @others = [ list.first, list.second ]
         f = form.has_many_field(:other_ids)
-        assert_equal 2, f.scan('</option>').size
+        assert_equal 2, f.scan("</option>").size
       end
 
-      test 'has_and_belongs_to_many_field with empty list' do
+      test "has_and_belongs_to_many_field with empty list" do
         @others = []
         f = form.has_many_field(:other_ids)
-        assert_match t('global.associations.none_available'), f
-        assert_equal 0, f.scan('</option>').size
+        assert_match t("global.associations.none_available"), f
+        assert_equal 0, f.scan("</option>").size
       end
 
-      test 'has_many_field has all options by default' do
+      test "has_many_field has all options by default" do
         f = form.has_many_field(:more_ids)
-        assert_equal 6, f.scan('</option>').size
+        assert_equal 6, f.scan("</option>").size
       end
 
-      test 'has_many_field with :list option' do
+      test "has_many_field with :list option" do
         list = OtherCrudTestModel.all
-        f = form.has_many_field(:more_ids, list: [list.first, list.second])
-        assert_equal 2, f.scan('</option>').size
+        f = form.has_many_field(:more_ids, list: [ list.first, list.second ])
+        assert_equal 2, f.scan("</option>").size
       end
 
-      test 'has_many_field with instance variable' do
+      test "has_many_field with instance variable" do
         list = OtherCrudTestModel.all
-        @mores = [list.first, list.second]
+        @mores = [ list.first, list.second ]
         f = form.has_many_field(:more_ids)
-        assert_equal 2, f.scan('</option>').size
+        assert_equal 2, f.scan("</option>").size
       end
 
-      test 'has_many_field with empty list' do
+      test "has_many_field with empty list" do
         @mores = []
         f = form.has_many_field(:more_ids)
-        assert_match t('global.associations.none_available'), f
-        assert_equal 0, f.scan('</option>').size
+        assert_match t("global.associations.none_available"), f
+        assert_equal 0, f.scan("</option>").size
       end
 
-      test 'string_field sets maxlength attribute if limit' do
+      test "string_field sets maxlength attribute if limit" do
         assert_match(/maxlength="50"/, form.string_field(:name))
       end
 
-      test 'label creates captionized label' do
+      test "label creates captionized label" do
         assert_match(/label [^>]*for.+Gugus dada/, form.label(:gugus_dada))
         assert form.label(:gugus_dada).html_safe?
       end
 
-      test 'classic label still works' do
-        assert_match(/label [^>]*for.+hoho/, form.label(:gugus_dada, 'hoho'))
-        assert form.label(:gugus_dada, 'hoho').html_safe?
+      test "classic label still works" do
+        assert_match(/label [^>]*for.+hoho/, form.label(:gugus_dada, "hoho"))
+        assert form.label(:gugus_dada, "hoho").html_safe?
       end
 
-      test 'labeled_text_field create label' do
+      test "labeled_text_field create label" do
         assert_match(/label [^>]*for.+input/m,
                      form.labeled_string_field(:name))
         assert form.labeled_string_field(:name).html_safe?
       end
 
-      test 'labeled field creates label' do
-        result = form.labeled('gugus',
+      test "labeled field creates label" do
+        result = form.labeled("gugus",
                               "<input type='text' name='gugus' />".html_safe)
         assert result.html_safe?
         assert_match(/label [^>]*for.+<input/m, result)
       end
 
-      test 'labeled field creates label and block' do
-        result = form.labeled('gugus') do
+      test "labeled field creates label and block" do
+        result = form.labeled("gugus") do
           "<input type='text' name='gugus' />".html_safe
         end
         assert result.html_safe?
         assert_match(/label [^>]*for.+<input/m, result)
       end
 
-      test 'labeled field creates label with caption' do
-        result = form.labeled('gugus',
+      test "labeled field creates label with caption" do
+        result = form.labeled("gugus",
                               "<input type='text' name='gugus' />".html_safe,
-                              caption: 'Caption')
+                              caption: "Caption")
         assert result.html_safe?
         assert_match(/label [^>]*for.+>Caption<\/label>.*<input/m, result)
       end
 
-      test 'labeled field creates label with caption and block' do
-        result = form.labeled('gugus', caption: 'Caption') do
+      test "labeled field creates label with caption and block" do
+        result = form.labeled("gugus", caption: "Caption") do
           "<input type='text' name='gugus' />".html_safe
         end
         assert result.html_safe?
         assert_match(/label [^>]*for.+>Caption<\/label>.*<input/m, result)
       end
 
-      test 'method missing still works' do
+      test "method missing still works" do
         assert_raise(NoMethodError) do
           form.blabla
         end
       end
 
-      test 'respond to still works' do
+      test "respond to still works" do
         assert_not form.respond_to?(:blalba)
         assert form.respond_to?(:text_field)
         assert form.respond_to?(:labeled_text_field)

data/lib/generators/dry_crud/templates/test/helpers/dry_crud/table/builder_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 module DryCrud
   module Table
@@ -20,47 +20,47 @@ module DryCrud
         "#{obj.size} chars"
       end
 
-      test 'html header' do
+      test "html header" do
         table.attrs :upcase, :size
 
-        dom = '<tr><th>Upcase</th><th>Size</th></tr>'
+        dom = "<tr><th>Upcase</th><th>Size</th></tr>"
 
         assert_dom_equal dom, table.send(:html_header)
       end
 
-      test 'single attr row' do
+      test "single attr row" do
         table.attrs :upcase, :size
 
-        dom = '<tr><td>FOO</td><td>3 chars</td></tr>'
+        dom = "<tr><td>FOO</td><td>3 chars</td></tr>"
 
         assert_dom_equal dom, table.send(:html_row, entries.first)
       end
 
-      test 'custom row' do
-        table.col('Header', class: 'hula') { |e| "Weights #{e.size} kg" }
+      test "custom row" do
+        table.col("Header", class: "hula") { |e| "Weights #{e.size} kg" }
 
         dom = '<tr><td class="hula">Weights 3 kg</td></tr>'
 
         assert_dom_equal dom, table.send(:html_row, entries.first)
       end
 
-      test 'attr col output' do
+      test "attr col output" do
         table.attrs :upcase
         col = table.cols.first
 
-        assert_equal '<th>Upcase</th>', col.html_header
-        assert_equal 'FOO', col.content('foo')
-        assert_equal '<td>FOO</td>', col.html_cell('foo')
+        assert_equal "<th>Upcase</th>", col.html_header
+        assert_equal "FOO", col.content("foo")
+        assert_equal "<td>FOO</td>", col.html_cell("foo")
       end
 
-      test 'attr col content with custom format_size method' do
+      test "attr col content with custom format_size method" do
         table.attrs :size
         col = table.cols.first
 
-        assert_equal '4 chars', col.content('abcd')
+        assert_equal "4 chars", col.content("abcd")
       end
 
-      test 'two x two table' do
+      test "two x two table" do
         dom = <<-FIN
           <table>
           <thead>
@@ -72,14 +72,14 @@ module DryCrud
           </tbody>
           </table>
         FIN
-        dom.gsub!(/[\n\t]/, '').gsub!(/\s{2,}/, '')
+        dom.gsub!(/[\n\t]/, "").gsub!(/\s{2,}/, "")
 
         table.attrs :upcase, :size
 
         assert_dom_equal dom, table.to_html
       end
 
-      test 'table with before and after cells' do
+      test "table with before and after cells" do
         dom = <<-FIN
           <table>
           <thead>
@@ -105,16 +105,16 @@ module DryCrud
           </tbody>
           </table>
         FIN
-        dom.gsub!(/[\n\t]/, '').gsub!(/\s{2,}/, '')
+        dom.gsub!(/[\n\t]/, "").gsub!(/\s{2,}/, "")
 
-        table.col('head', class: 'left') { |e| link_to e, '/' }
+        table.col("head", class: "left") { |e| link_to e, "/" }
         table.attrs :upcase, :size
         table.col { |e| "Never #{e}" }
 
         assert_dom_equal dom, table.to_html
       end
 
-      test 'empty entries collection renders empty table' do
+      test "empty entries collection renders empty table" do
         dom = <<-FIN
           <table>
           <thead>
@@ -129,10 +129,10 @@ module DryCrud
           </tbody>
           </table>
         FIN
-        dom.gsub!(/[\n\t]/, '').gsub!(/\s{2,}/, '')
+        dom.gsub!(/[\n\t]/, "").gsub!(/\s{2,}/, "")
 
         table = DryCrud::Table::Builder.new([], self)
-        table.col('head', class: 'left') { |e| link_to e, '/' }
+        table.col("head", class: "left") { |e| link_to e, "/" }
         table.attrs :upcase, :size
         table.col { |e| "Never #{e}" }
 

data/lib/generators/dry_crud/templates/test/helpers/form_helper_test.rb

@@ -1,10 +1,9 @@
-require 'test_helper'
-require 'support/crud_test_model'
-require 'support/crud_test_helper'
+require "test_helper"
+require "support/crud_test_model"
+require "support/crud_test_helper"
 
 # Test FormHelper
 class FormHelperTest < ActionView::TestCase
-
   include UtilityHelper
   include FormatHelper
   include I18nHelper
@@ -13,11 +12,11 @@ class FormHelperTest < ActionView::TestCase
   setup :reset_db, :setup_db, :create_test_data
   teardown :reset_db
 
-  test 'plain form for existing entry' do
-    e = crud_test_models('AAAAA')
+  test "plain form for existing entry" do
+    e = crud_test_models("AAAAA")
     f = with_test_routing do
       capture do
-        plain_form(e, html: { class: 'special' }) do |form|
+        plain_form(e, html: { class: "special" }) do |form|
           form.labeled_input_fields :name, :birthdate
         end
       end
@@ -34,14 +33,14 @@ class FormHelperTest < ActionView::TestCase
                         .*?name="crud_test_model\[name\]"/x, f)
   end
 
-  test 'standard form' do
-    e = crud_test_models('AAAAA')
+  test "standard form" do
+    e = crud_test_models("AAAAA")
     f = with_test_routing do
       capture do
         standard_form(e,
                       :name, :children, :birthdate, :human,
-                      cancel_url: '/somewhere',
-                      html: { class: 'special' })
+                      cancel_url: "/somewhere",
+                      html: { class: "special" })
       end
     end
 
@@ -57,20 +56,20 @@ class FormHelperTest < ActionView::TestCase
     assert_match(/input .*?type="date"
                         .*?name="crud_test_model\[birthdate\]"/x, f)
     assert_match(/input .*?type="number"
-                        .*?value=\"9\"
+                        .*?value="9"
                         .*?name="crud_test_model\[children\]"/x, f)
     assert_match(/input .*?type="checkbox"
                         .*?name="crud_test_model\[human\]"/x, f)
-    assert_match(/button\ .*?type="submit".*\>
+    assert_match(/button\ .*?type="submit".*>
                   #{t('global.button.save')}
-                  \<\/button\>/x, f)
-    assert_match(/\<a\ .*href="\/somewhere".*\>
+                  <\/button>/x, f)
+    assert_match(/<a\ .*href="\/somewhere".*>
                   #{t('global.button.cancel')}
-                  \<\/a\>/x, f)
+                  <\/a>/x, f)
   end
 
-  test 'standard form with errors' do
-    e = crud_test_models('AAAAA')
+  test "standard form with errors" do
+    e = crud_test_models("AAAAA")
     e.name = nil
     assert_not e.valid?
 
@@ -88,15 +87,15 @@ class FormHelperTest < ActionView::TestCase
                         .*?name="_method"
                         .*?value="(patch|put)"/x, f)
     assert_match(/div[^>]* id='error_explanation'/, f)
-    assert_match(/div\ class="form-group\ has-error"\>.*?
-                  \<input .*?type="text"
-                          .*?name="crud_test_model\[name\]"/x, f)
+    assert_match(/input .*?class="is-invalid\ form-control"
+                         .*?type="text"
+                         .*?name="crud_test_model\[name\]"/x, f)
     assert_match(/input .*?value="1910-01-01"
                         .*?type="date"
                         .*?name="crud_test_model\[birthdate\]"/x, f)
   end
 
-  test 'crud form' do
+  test "crud form" do
     f = with_test_routing do
       capture { crud_form }
     end
@@ -129,5 +128,4 @@ class FormHelperTest < ActionView::TestCase
   def entry
     @entry ||= CrudTestModel.first
   end
-
 end