dry_crud 6.0.0 → 8.0.0

data/lib/generators/dry_crud/templates/spec/helpers/format_helper_spec.rb

@@ -1,7 +1,6 @@
-require 'rails_helper'
+require "rails_helper"
 
 describe FormatHelper do
-
   include UtilityHelper
   include I18nHelper
   include CrudTestHelper
@@ -15,17 +14,17 @@ describe FormatHelper do
   after(:all) { reset_db }
 
   # define some test format_ methods
-  def format_size(obj) #:nodoc:
+  def format_size(obj) # :nodoc:
     "#{f(obj.size)} items"
   end
 
-  def format_string_size(obj) #:nodoc:
+  def format_string_size(obj) # :nodoc:
     "#{f(obj.size)} chars"
   end
 
-  describe '#labeled' do
-    context 'regular' do
-      subject { labeled('label') { 'value' } }
+  describe "#labeled" do
+    context "regular" do
+      subject { labeled("label") { "value" } }
 
       it { is_expected.to be_html_safe }
       it do
@@ -36,8 +35,8 @@ describe FormatHelper do
       end
     end
 
-    context 'with empty value' do
-      subject { labeled('label') { '' } }
+    context "with empty value" do
+      subject { labeled("label") { "" } }
 
       it { is_expected.to be_html_safe }
       it do
@@ -45,13 +44,13 @@ describe FormatHelper do
           /<dt>label<\/dt>
            \ <dd\ class=['"]value['"]>
            #{UtilityHelper::EMPTY_STRING}
-           <\/dd>$/x
+           <\/dd>$/xo
         )
       end
     end
 
-    context 'with unsafe value' do
-      subject { labeled('label') { 'value <unsafe>' } }
+    context "with unsafe value" do
+      subject { labeled("label") { "value <unsafe>" } }
 
       it { is_expected.to be_html_safe }
       it do
@@ -65,8 +64,8 @@ describe FormatHelper do
     end
   end
 
-  describe '#labeled_attr' do
-    subject { labeled_attr('foo', :size) }
+  describe "#labeled_attr" do
+    subject { labeled_attr("foo", :size) }
 
     it { is_expected.to be_html_safe }
     it do
@@ -77,110 +76,108 @@ describe FormatHelper do
     end
   end
 
-  describe '#f' do
-
-    unless ENV['NON_LOCALIZED'] # localization dependent tests
-      context 'Floats' do
-        it 'adds two digits' do
-          expect(f(1.0)).to eq('1.000')
+  describe "#f" do
+    unless ENV["NON_LOCALIZED"] # localization dependent tests
+      context "Floats" do
+        it "adds two digits" do
+          expect(f(1.0)).to eq("1.000")
         end
 
-        it 'truncates to two digits' do
-          expect(f(3.14159)).to eq('3.142')
+        it "truncates to two digits" do
+          expect(f(3.14159)).to eq("3.142")
         end
 
-        it 'adds delimiters' do
-          expect(f(12_345.6789)).to eq('12,345.679')
+        it "adds delimiters" do
+          expect(f(12_345.6789)).to eq("12,345.679")
         end
       end
 
-      context 'Booleans' do
-        it 'true is_expected.to print yes' do
-          expect(f(true)).to eq('yes')
+      context "Booleans" do
+        it "true is_expected.to print yes" do
+          expect(f(true)).to eq("yes")
         end
 
-        it 'false is_expected.to print no' do
-          expect(f(false)).to eq('no')
+        it "false is_expected.to print no" do
+          expect(f(false)).to eq("no")
         end
       end
 
-      context 'Dates' do
-        it 'prints regular date' do
-          expect(f(Date.new(2013, 6, 9))).to eq('2013-06-09')
+      context "Dates" do
+        it "prints regular date" do
+          expect(f(Date.new(2013, 6, 9))).to eq("2013-06-09")
         end
       end
 
-      context 'Times' do
-        it 'prints regular date' do
-          expect(f(Time.utc(2013, 6, 9, 21, 25))).to eq('2013-06-09 21:25')
+      context "Times" do
+        it "prints regular date" do
+          expect(f(Time.utc(2013, 6, 9, 21, 25))).to eq("2013-06-09 21:25")
         end
       end
     end
 
-    context 'nil' do
-      it 'prints an empty string' do
+    context "nil" do
+      it "prints an empty string" do
         expect(f(nil)).to eq(UtilityHelper::EMPTY_STRING)
       end
     end
 
-    context 'Strings' do
-      it 'prints regular strings unchanged' do
-        expect(f('blah blah')).to eq('blah blah')
+    context "Strings" do
+      it "prints regular strings unchanged" do
+        expect(f("blah blah")).to eq("blah blah")
       end
 
-      it 'is not html safe' do
-        expect(f('<injection>')).not_to be_html_safe
+      it "is not html safe" do
+        expect(f("<injection>")).not_to be_html_safe
       end
     end
-
   end
 
-  describe '#format_attr' do
-    it 'uses #f' do
-      expect(format_attr('12.342', :to_f)).to eq(f(12.342))
+  describe "#format_attr" do
+    it "uses #f" do
+      expect(format_attr("12.342", :to_f)).to eq(f(12.342))
     end
 
-    it 'uses object attr format method if it exists' do
-      expect(format_attr('abcd', :size)).to eq('4 chars')
+    it "uses object attr format method if it exists" do
+      expect(format_attr("abcd", :size)).to eq("4 chars")
     end
 
-    it 'uses general attr format method if it exists' do
-      expect(format_attr([1, 2], :size)).to eq('2 items')
+    it "uses general attr format method if it exists" do
+      expect(format_attr([ 1, 2 ], :size)).to eq("2 items")
     end
 
-    it 'formats empty belongs_to' do
+    it "formats empty belongs_to" do
       expect(format_attr(crud_test_models(:AAAAA), :companion)).to eq(
-        t('global.associations.no_entry')
+        t("global.associations.no_entry")
       )
     end
 
-    it 'formats existing belongs_to' do
+    it "formats existing belongs_to" do
       string = format_attr(crud_test_models(:BBBBB), :companion)
-      expect(string).to eq('AAAAA')
+      expect(string).to eq("AAAAA")
     end
 
-    it 'formats empty has_one' do
+    it "formats empty has_one" do
       expect(format_attr(crud_test_models(:FFFFF), :comrad)).to eq(
-        t('global.associations.no_entry')
+        t("global.associations.no_entry")
       )
     end
 
-    it 'formats existing has_one' do
+    it "formats existing has_one" do
       string = format_attr(crud_test_models(:AAAAA), :comrad)
-      expect(string).to eq('BBBBB')
+      expect(string).to eq("BBBBB")
     end
 
-    it 'formats existing has_many' do
+    it "formats existing has_many" do
       string = format_attr(crud_test_models(:CCCCC), :others)
       expect(string).to be_html_safe
-      expect(string).to eq('<ul><li>AAAAA</li><li>BBBBB</li></ul>')
+      expect(string).to eq("<ul><li>AAAAA</li><li>BBBBB</li></ul>")
     end
   end
 
-  describe '#column_type' do
+  describe "#column_type" do
     let(:model) { crud_test_models(:AAAAA) }
 
-    it 'recognizes types' do
+    it "recognizes types" do
       expect(column_type(model, :name)).to eq(:string)
       expect(column_type(model, :children)).to eq(:integer)
       expect(column_type(model, :companion_id)).to eq(:integer)
@@ -195,47 +192,47 @@ describe FormatHelper do
     end
   end
 
-  describe '#format_type' do
+  describe "#format_type" do
     let(:model) { crud_test_models(:AAAAA) }
 
-    it 'formats integers' do
+    it "formats integers" do
       model.children = 10_000
-      expect(format_type(model, :children)).to eq('10,000')
+      expect(format_type(model, :children)).to eq("10,000")
     end
 
-    unless ENV['NON_LOCALIZED'] # localization dependent tests
-      it 'formats floats' do
-        expect(format_type(model, :rating)).to eq('1.100')
+    unless ENV["NON_LOCALIZED"] # localization dependent tests
+      it "formats floats" do
+        expect(format_type(model, :rating)).to eq("1.100")
       end
 
-      it 'formata decimals' do
-        expect(format_type(model, :income)).to eq('10,000,000.1111')
+      it "formata decimals" do
+        expect(format_type(model, :income)).to eq("10,000,000.1111")
       end
 
-      it 'formats dates' do
-        expect(format_type(model, :birthdate)).to eq('1910-01-01')
+      it "formats dates" do
+        expect(format_type(model, :birthdate)).to eq("1910-01-01")
       end
 
-      it 'formats times' do
-        expect(format_type(model, :gets_up_at)).to eq('01:01')
+      it "formats times" do
+        expect(format_type(model, :gets_up_at)).to eq("01:01")
       end
 
-      it 'formats datetimes' do
-        expect(format_type(model, :last_seen)).to eq('2010-01-01 11:21')
+      it "formats datetimes" do
+        expect(format_type(model, :last_seen)).to eq("2010-01-01 11:21")
       end
 
-      it 'formats boolean false' do
+      it "formats boolean false" do
         model.human = false
-        expect(format_type(model, :human)).to eq('no')
+        expect(format_type(model, :human)).to eq("no")
       end
 
-      it 'formats boolean true' do
+      it "formats boolean true" do
         model.human = true
-        expect(format_type(model, :human)).to eq('yes')
+        expect(format_type(model, :human)).to eq("yes")
       end
     end
 
-    it 'formats texts' do
+    it "formats texts" do
       string = format_type(model, :remarks)
       expect(string).to be_html_safe
       expect(string).to eq(
@@ -243,33 +240,32 @@ describe FormatHelper do
       )
     end
 
-    it 'escapes texts' do
-      model.remarks = '<unsecure>bla'
+    it "escapes texts" do
+      model.remarks = "<unsecure>bla"
       string = format_type(model, :remarks)
       expect(string).to be_html_safe
-      expect(string).to eq('<p>&lt;unsecure&gt;bla</p>')
+      expect(string).to eq("<p>&lt;unsecure&gt;bla</p>")
     end
 
-    it 'formats empty texts' do
-      model.remarks = '   '
+    it "formats empty texts" do
+      model.remarks = "   "
       string = format_type(model, :remarks)
       expect(string).to be_html_safe
       expect(string).to eq(UtilityHelper::EMPTY_STRING)
     end
   end
 
-  describe '#captionize' do
-    it 'handles symbols' do
-      expect(captionize(:camel_case)).to eq('Camel Case')
+  describe "#captionize" do
+    it "handles symbols" do
+      expect(captionize(:camel_case)).to eq("Camel Case")
     end
 
-    it 'renders all upper case' do
-      expect(captionize('all upper case')).to eq('All Upper Case')
+    it "renders all upper case" do
+      expect(captionize("all upper case")).to eq("All Upper Case")
     end
 
-    it 'renders human attribute name' do
-      expect(captionize(:gets_up_at, CrudTestModel)).to eq('Gets up at')
+    it "renders human attribute name" do
+      expect(captionize(:gets_up_at, CrudTestModel)).to eq("Gets up at")
     end
   end
-
 end

data/lib/generators/dry_crud/templates/spec/helpers/i18n_helper_spec.rb

@@ -1,101 +1,100 @@
-require 'rails_helper'
+require "rails_helper"
 
 describe I18nHelper do
-
   include CrudTestHelper
 
-  describe '#translate_inheritable' do
+  describe "#translate_inheritable" do
     before { @controller = CrudTestModelsController.new }
 
     before do
       I18n.backend.store_translations(
         I18n.locale,
         global: {
-          test_key: 'global'
+          test_key: "global"
         }
       )
     end
     subject { ti(:test_key) }
 
-    it { is_expected.to eq('global') }
+    it { is_expected.to eq("global") }
 
-    context 'with list key' do
+    context "with list key" do
       before do
         I18n.backend.store_translations(
           I18n.locale,
           list: {
             global: {
-              test_key: 'list global'
+              test_key: "list global"
             }
           }
         )
       end
-      it { is_expected.to eq('list global') }
+      it { is_expected.to eq("list global") }
 
-      context 'and list action key' do
+      context "and list action key" do
         before do
           I18n.backend.store_translations(
             I18n.locale,
             list: {
               index: {
-                test_key: 'list index'
+                test_key: "list index"
               }
             }
           )
         end
-        it { is_expected.to eq('list index') }
+        it { is_expected.to eq("list index") }
 
-        context 'and crud global key' do
+        context "and crud global key" do
           before do
             I18n.backend.store_translations(
               I18n.locale,
               crud: {
                 global: {
-                  test_key: 'crud global'
+                  test_key: "crud global"
                 }
               }
             )
           end
-          it { is_expected.to eq('crud global') }
+          it { is_expected.to eq("crud global") }
 
-          context 'and crud action key' do
+          context "and crud action key" do
             before do
               I18n.backend.store_translations(
                 I18n.locale,
                 crud: {
                   index: {
-                    test_key: 'crud index'
+                    test_key: "crud index"
                   }
                 }
               )
             end
-            it { is_expected.to eq('crud index') }
+            it { is_expected.to eq("crud index") }
 
-            context 'and controller global key' do
+            context "and controller global key" do
               before do
                 I18n.backend.store_translations(
                   I18n.locale,
                   crud_test_models: {
                     global: {
-                      test_key: 'test global'
+                      test_key: "test global"
                     }
                   }
                 )
               end
-              it { is_expected.to eq('test global') }
+              it { is_expected.to eq("test global") }
 
-              context 'and controller action key' do
+              context "and controller action key" do
                 before do
                   I18n.backend.store_translations(
                     I18n.locale,
                     crud_test_models: {
                       index: {
-                        test_key: 'test index'
+                        test_key: "test index"
                       }
                     }
                   )
                 end
-                it { is_expected.to eq('test index') }
+                it { is_expected.to eq("test index") }
               end
             end
           end
@@ -104,7 +103,7 @@ describe I18nHelper do
     end
   end
 
-  describe '#translate_association' do
+  describe "#translate_association" do
     let(:assoc) { CrudTestModel.reflect_on_association(:companion) }
     subject { ta(:test_key, assoc) }
 
@@ -113,30 +112,30 @@ describe I18nHelper do
         I18n.locale,
         global: {
           associations: {
-            test_key: 'global'
+            test_key: "global"
           }
         }
       )
     end
-    it { is_expected.to eq('global') }
+    it { is_expected.to eq("global") }
 
-    context 'with model key' do
+    context "with model key" do
       before do
         I18n.backend.store_translations(
           I18n.locale,
           activerecord: {
             associations: {
               crud_test_model: {
-                test_key: 'model'
+                test_key: "model"
               }
             }
           }
         )
       end
 
-      it { is_expected.to eq('model') }
+      it { is_expected.to eq("model") }
 
-      context 'and assoc key' do
+      context "and assoc key" do
         before do
           I18n.backend.store_translations(
             I18n.locale,
@@ -145,7 +144,7 @@ describe I18nHelper do
                 models: {
                   crud_test_model: {
                     companion: {
-                      test_key: 'companion'
+                      test_key: "companion"
                     }
                   }
                 }
@@ -154,9 +153,9 @@ describe I18nHelper do
           )
         end
 
-        it { is_expected.to eq('companion') }
-        it 'uses global without assoc' do
-          expect(ta(:test_key)).to eq('global')
+        it { is_expected.to eq("companion") }
+        it "uses global without assoc" do
+          expect(ta(:test_key)).to eq("global")
         end
       end
     end