magicka 0.6.0 → 1.1.0

data/spec/lib/magicka/aggregator/class_methods_spec.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Magicka::Aggregator::ClassMethods do
+  subject(:aggregator) { aggregator_class.new(renderer, model) }
+
+  let(:aggregator_class) { Class.new(Magicka::Aggregator) }
+  let(:model)            { :my_model }
+  let(:renderer)         { instance_double('renderer') }
+  let(:template)         { 'templates/forms/input' }
+  let(:locals)           { {} }
+
+  describe '.type' do
+    let(:type) { %w[form display other].sample }
+
+    it 'sets aggregator type' do
+      expect { aggregator_class.type(type) }
+        .to change(aggregator_class, :type)
+        .from(nil).to(type.to_sym)
+    end
+
+    context 'when type has not been set' do
+      let(:aggregator_class) do
+        Class.new(Magicka::Aggregator) do
+          def self.name
+            'Magicka::MyClass'
+          end
+        end
+      end
+
+      it 'Uses class name as type' do
+        expect(aggregator_class.type)
+          .to eq(:my_class)
+      end
+    end
+  end
+
+  describe '.with_element' do
+    let(:element_class) { Magicka::Input }
+
+    context 'when seeting element class only' do
+      it do
+        expect { aggregator_class.with_element(element_class) }
+          .to add_method(:input)
+          .to(aggregator)
+      end
+
+      context 'when built method is called' do
+        let(:template)    { 'templates/forms/input' }
+        let(:field)       { :field }
+        let(:label)       { 'Label' }
+        let(:placeholder) { 'Value' }
+
+        let(:locals) do
+          {
+            field: field,
+            label: label,
+            ng_errors: 'my_model.errors.field',
+            ng_model: 'my_model.field',
+            placeholder: placeholder
+          }
+        end
+
+        let(:arguments) do
+          {
+            label: label,
+            placeholder: placeholder
+          }
+        end
+
+        before do
+          aggregator_class.with_element(element_class)
+
+          allow(renderer)
+            .to receive(:render)
+            .with(partial: template, locals: locals)
+        end
+
+        it 'renders an input' do
+          aggregator.input(field, **arguments)
+
+          expect(renderer).to have_received(:render)
+        end
+
+        context 'when passing a custom model' do
+          let(:locals) do
+            {
+              field: field,
+              label: label,
+              ng_errors: 'my_custom_model.errors.field',
+              ng_model: 'my_custom_model.field',
+              placeholder: placeholder
+            }
+          end
+
+          it 'renders an input' do
+            aggregator.input(field, model: 'my_custom_model', **arguments)
+
+            expect(renderer).to have_received(:render)
+          end
+        end
+      end
+    end
+
+    context 'when seeting element class and method' do
+      it do
+        expect { aggregator_class.with_element(element_class, :my_input) }
+          .to add_method(:my_input)
+          .to(aggregator)
+      end
+
+      context 'when built method is called' do
+        let(:template)    { 'templates/forms/input' }
+        let(:field)       { :field }
+        let(:label)       { 'Label' }
+        let(:placeholder) { 'Value' }
+
+        let(:locals) do
+          {
+            field: field,
+            label: label,
+            ng_errors: 'my_model.errors.field',
+            ng_model: 'my_model.field',
+            placeholder: placeholder
+          }
+        end
+
+        let(:arguments) do
+          {
+            label: label,
+            placeholder: placeholder
+          }
+        end
+
+        before do
+          aggregator_class.with_element(element_class, :my_input)
+
+          allow(renderer)
+            .to receive(:render)
+            .with(partial: template, locals: locals)
+        end
+
+        it 'renders an input' do
+          aggregator.my_input(field, **arguments)
+
+          expect(renderer).to have_received(:render)
+        end
+
+        context 'when passing a custom model' do
+          let(:locals) do
+            {
+              field: field,
+              label: label,
+              ng_errors: 'my_custom_model.errors.field',
+              ng_model: 'my_custom_model.field',
+              placeholder: placeholder
+            }
+          end
+
+          it 'renders an input' do
+            aggregator.my_input(field, model: 'my_custom_model', **arguments)
+
+            expect(renderer).to have_received(:render)
+          end
+        end
+      end
+    end
+
+    context 'when setting element class and template' do
+      it do
+        expect do
+          aggregator_class.with_element(element_class, template: template)
+        end
+          .to add_method(:input)
+          .to(aggregator)
+      end
+
+      context 'when built method is called' do
+        let(:template)    { 'my_templates/my_input' }
+        let(:field)       { :field }
+        let(:label)       { 'Label' }
+        let(:placeholder) { 'Value' }
+
+        let(:locals) do
+          {
+            field: field,
+            label: label,
+            ng_errors: 'my_model.errors.field',
+            ng_model: 'my_model.field',
+            placeholder: placeholder
+          }
+        end
+
+        let(:arguments) do
+          {
+            label: label,
+            placeholder: placeholder
+          }
+        end
+
+        before do
+          aggregator_class.with_element(element_class, template: template)
+
+          allow(renderer)
+            .to receive(:render)
+            .with(partial: template, locals: locals)
+        end
+
+        it 'renders an input' do
+          aggregator.input(field, **arguments)
+
+          expect(renderer).to have_received(:render)
+        end
+
+        context 'when passing a custom model' do
+          let(:locals) do
+            {
+              field: field,
+              label: label,
+              ng_errors: 'my_custom_model.errors.field',
+              ng_model: 'my_custom_model.field',
+              placeholder: placeholder
+            }
+          end
+
+          it 'renders an input' do
+            aggregator.input(field, model: 'my_custom_model', **arguments)
+
+            expect(renderer).to have_received(:render)
+          end
+        end
+      end
+    end
+
+    context 'when element class is defined with a string' do
+      let(:element_class) { 'Magicka::Input' }
+
+      it do
+        expect { aggregator_class.with_element(element_class) }
+          .to add_method(:input)
+          .to(aggregator)
+      end
+
+      context 'when built method is called' do
+        let(:template)    { 'templates/forms/input' }
+        let(:field)       { :field }
+        let(:label)       { 'Label' }
+        let(:placeholder) { 'Value' }
+
+        let(:locals) do
+          {
+            field: field,
+            label: label,
+            ng_errors: 'my_model.errors.field',
+            ng_model: 'my_model.field',
+            placeholder: placeholder
+          }
+        end
+
+        let(:arguments) do
+          {
+            label: label,
+            placeholder: placeholder
+          }
+        end
+
+        before do
+          aggregator_class.with_element(element_class)
+
+          allow(renderer)
+            .to receive(:render)
+            .with(partial: template, locals: locals)
+        end
+
+        it 'renders an input' do
+          aggregator.input(field, **arguments)
+
+          expect(renderer).to have_received(:render)
+        end
+
+        context 'when passing a custom model' do
+          let(:locals) do
+            {
+              field: field,
+              label: label,
+              ng_errors: 'my_custom_model.errors.field',
+              ng_model: 'my_custom_model.field',
+              placeholder: placeholder
+            }
+          end
+
+          it 'renders an input' do
+            aggregator.input(field, model: 'my_custom_model', **arguments)
+
+            expect(renderer).to have_received(:render)
+          end
+        end
+      end
+    end
+
+    context 'when element class is defined with a string and the element loaded later' do
+      let(:element_class) { 'Magicka::SpecDefinedInput' }
+
+      it do
+        expect { aggregator_class.with_element(element_class, :input) }
+          .to add_method(:input)
+          .to(aggregator)
+      end
+
+      context 'when built method is called' do
+        let(:template)    { 'templates/forms/my_input' }
+        let(:field)       { :field }
+        let(:label)       { 'Label' }
+        let(:placeholder) { 'Value' }
+
+        let(:locals) do
+          {
+            field: field,
+            label: label,
+            ng_errors: 'my_model.errors.field',
+            ng_model: 'my_model.field',
+            placeholder: placeholder
+          }
+        end
+
+        let(:arguments) do
+          {
+            label: label,
+            placeholder: placeholder
+          }
+        end
+
+        before do
+          aggregator_class.with_element(element_class, :input, template: template)
+
+          Magicka.const_set(:SpecDefinedInput, Class.new(Magicka::Input))
+
+          allow(renderer)
+            .to receive(:render)
+            .with(partial: template, locals: locals)
+        end
+
+        it 'renders an input' do
+          aggregator.input(field, **arguments)
+
+          expect(renderer).to have_received(:render)
+        end
+      end
+    end
+  end
+end

data/spec/lib/magicka/aggregator/method_builder_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Magicka::Aggregator::MethodBuilder do
+  subject(:builder) do
+    aggregator_class.new(aggregator_class, element_class_arg)
+  end
+
+  let(:aggregator_class)  { Class.new(described_class) }
+  let(:element_class_arg) { element_class }
+  let(:element_class)     { Magicka::MyElement }
+
+  describe '#element_class' do
+    context 'when passing an element class' do
+      it do
+        expect(builder.element_class).to eq(element_class)
+      end
+    end
+
+    context 'when passing an element class name' do
+      let(:element_class_arg) { element_class.to_s }
+
+      it do
+        expect(builder.element_class).to eq(element_class)
+      end
+    end
+  end
+end

data/spec/lib/magicka/aggregator_spec.rb

@@ -11,227 +11,6 @@ describe Magicka::Aggregator do
   let(:template)         { 'templates/forms/input' }
   let(:locals)           { {} }
 
-  describe '.type' do
-    let(:type) { %w[form display other].sample }
-
-    it 'sets aggregator type' do
-      expect { aggregator_class.type(type) }
-        .to change(aggregator_class, :type)
-        .from(nil).to(type.to_sym)
-    end
-
-    context 'when type has not been set' do
-      let(:aggregator_class) do
-        Class.new(described_class) do
-          def self.name
-            'Magicka::MyClass'
-          end
-        end
-      end
-
-      it 'Uses class name as type' do
-        expect(aggregator_class.type)
-          .to eq(:my_class)
-      end
-    end
-  end
-
-  describe '.with_element' do
-    context 'when seeting element class only' do
-      it do
-        expect { aggregator_class.with_element(Magicka::Input) }
-          .to add_method(:input)
-          .to(aggregator)
-      end
-
-      context 'when built method is called' do
-        let(:template)    { 'templates/forms/input' }
-        let(:field)       { :field }
-        let(:label)       { 'Label' }
-        let(:placeholder) { 'Value' }
-
-        let(:locals) do
-          {
-            field: field,
-            label: label,
-            ng_errors: 'my_model.errors.field',
-            ng_model: 'my_model.field',
-            placeholder: placeholder
-          }
-        end
-
-        let(:arguments) do
-          {
-            label: label,
-            placeholder: placeholder
-          }
-        end
-
-        before do
-          aggregator_class.with_element(Magicka::Input)
-
-          allow(renderer)
-            .to receive(:render)
-            .with(partial: template, locals: locals)
-        end
-
-        it 'renders an input' do
-          aggregator.input(field, arguments)
-
-          expect(renderer).to have_received(:render)
-        end
-
-        context 'when passing a custom model' do
-          let(:locals) do
-            {
-              field: field,
-              label: label,
-              ng_errors: 'my_custom_model.errors.field',
-              ng_model: 'my_custom_model.field',
-              placeholder: placeholder
-            }
-          end
-
-          it 'renders an input' do
-            aggregator.input(field, model: 'my_custom_model', **arguments)
-
-            expect(renderer).to have_received(:render)
-          end
-        end
-      end
-    end
-
-    context 'when seeting element class and method' do
-      it do
-        expect { aggregator_class.with_element(Magicka::Input, :my_input) }
-          .to add_method(:my_input)
-          .to(aggregator)
-      end
-
-      context 'when built method is called' do
-        let(:template)    { 'templates/forms/input' }
-        let(:field)       { :field }
-        let(:label)       { 'Label' }
-        let(:placeholder) { 'Value' }
-
-        let(:locals) do
-          {
-            field: field,
-            label: label,
-            ng_errors: 'my_model.errors.field',
-            ng_model: 'my_model.field',
-            placeholder: placeholder
-          }
-        end
-
-        let(:arguments) do
-          {
-            label: label,
-            placeholder: placeholder
-          }
-        end
-
-        before do
-          aggregator_class.with_element(Magicka::Input, :my_input)
-
-          allow(renderer)
-            .to receive(:render)
-            .with(partial: template, locals: locals)
-        end
-
-        it 'renders an input' do
-          aggregator.my_input(field, arguments)
-
-          expect(renderer).to have_received(:render)
-        end
-
-        context 'when passing a custom model' do
-          let(:locals) do
-            {
-              field: field,
-              label: label,
-              ng_errors: 'my_custom_model.errors.field',
-              ng_model: 'my_custom_model.field',
-              placeholder: placeholder
-            }
-          end
-
-          it 'renders an input' do
-            aggregator.my_input(field, model: 'my_custom_model', **arguments)
-
-            expect(renderer).to have_received(:render)
-          end
-        end
-      end
-    end
-
-    context 'when seeting element class and template' do
-      it do
-        expect do
-          aggregator_class.with_element(Magicka::Input, template: template)
-        end
-          .to add_method(:input)
-          .to(aggregator)
-      end
-
-      context 'when built method is called' do
-        let(:template)    { 'my_templates/my_input' }
-        let(:field)       { :field }
-        let(:label)       { 'Label' }
-        let(:placeholder) { 'Value' }
-
-        let(:locals) do
-          {
-            field: field,
-            label: label,
-            ng_errors: 'my_model.errors.field',
-            ng_model: 'my_model.field',
-            placeholder: placeholder
-          }
-        end
-
-        let(:arguments) do
-          {
-            label: label,
-            placeholder: placeholder
-          }
-        end
-
-        before do
-          aggregator_class.with_element(Magicka::Input, template: template)
-
-          allow(renderer)
-            .to receive(:render)
-            .with(partial: template, locals: locals)
-        end
-
-        it 'renders an input' do
-          aggregator.input(field, arguments)
-
-          expect(renderer).to have_received(:render)
-        end
-
-        context 'when passing a custom model' do
-          let(:locals) do
-            {
-              field: field,
-              label: label,
-              ng_errors: 'my_custom_model.errors.field',
-              ng_model: 'my_custom_model.field',
-              placeholder: placeholder
-            }
-          end
-
-          it 'renders an input' do
-            aggregator.input(field, model: 'my_custom_model', **arguments)
-
-            expect(renderer).to have_received(:render)
-          end
-        end
-      end
-    end
-  end
-
   describe '#with_model' do
     let(:expected_aggregator) do
       aggregator_class.new(renderer, 'my_model.inner')

data/spec/lib/magicka/button_spec.rb

@@ -38,7 +38,7 @@ describe Magicka::Button do
     end
 
     it do
-      described_class.render(arguments)
+      described_class.render(**arguments)
 
       expect(renderer).to have_received(:render)
     end

data/spec/lib/magicka/display_spec.rb

@@ -45,7 +45,7 @@ describe Magicka::Display do
     end
 
     it 'renders a text' do
-      form.input(field, arguments)
+      form.input(field, **arguments)
 
       expect(renderer).to have_received(:render)
     end
@@ -91,7 +91,7 @@ describe Magicka::Display do
     end
 
     it 'renders a text' do
-      form.select(field, arguments)
+      form.select(field, **arguments)
 
       expect(renderer).to have_received(:render)
     end
@@ -130,7 +130,7 @@ describe Magicka::Display do
     end
 
     it 'renders nothing' do
-      form.button(arguments)
+      form.button(**arguments)
 
       expect(renderer).not_to have_received(:render)
     end

data/spec/lib/magicka/form_element_spec.rb

@@ -44,7 +44,7 @@ describe Magicka::FormElement do
       end
 
       it do
-        klass.render(arguments)
+        klass.render(**arguments)
 
         expect(renderer).to have_received(:render)
       end
@@ -70,7 +70,7 @@ describe Magicka::FormElement do
       end
 
       it do
-        klass.render(arguments)
+        klass.render(**arguments)
 
         expect(renderer).to have_received(:render)
       end

data/spec/lib/magicka/form_spec.rb

@@ -46,7 +46,7 @@ describe Magicka::Form do
     end
 
     it 'renders an input' do
-      form.input(field, arguments)
+      form.input(field, **arguments)
 
       expect(renderer).to have_received(:render)
     end
@@ -94,7 +94,7 @@ describe Magicka::Form do
     end
 
     it 'renders a select' do
-      form.select(field, arguments)
+      form.select(field, **arguments)
 
       expect(renderer).to have_received(:render)
     end
@@ -144,7 +144,7 @@ describe Magicka::Form do
     end
 
     it 'renders an input' do
-      form.button(arguments)
+      form.button(**arguments)
 
       expect(renderer).to have_received(:render)
     end