magicka 1.0.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/helper/aggregator_options_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Magicka::Helper::AggregatorOptions do
+  subject(:options) { described_class.new(options_hash) }
+
+  let(:options_hash) do
+    {
+      aggregator: aggregator,
+      type: type,
+      config_block: config_block
+    }
+  end
+
+  let(:aggregator_class) { Class.new(Magicka::Aggregator) }
+  let(:aggregator)       { aggregator_class }
+  let(:type)             { :my_aggregator }
+  let(:config_block) do
+    proc { with_element(Magicka::Input) }
+  end
+
+  describe '#configured_aggregator' do
+    let(:renderer)       { instance_double(ActionView::OutputBuffer) }
+    let(:model)          { Object.new }
+    let(:element_class)  { Magicka::Input }
+
+    before do
+      allow(element_class).to receive(:render).with(
+        renderer: renderer,
+        field: :name,
+        model: model,
+        template: nil
+      )
+    end
+
+    context 'when aggregator is a class' do
+      context 'when config block is given' do
+        it 'returns the given aggregator class' do
+          expect(options.configured_aggregator)
+            .to be(aggregator)
+        end
+
+        it 'configure the aggregator' do
+          options.configured_aggregator.new(renderer, model)
+                 .input(:name)
+
+          expect(element_class).to have_received(:render)
+        end
+      end
+
+      context 'when config block is not given' do
+        let(:config_block) { nil }
+
+        it 'returns the given aggregator class' do
+          expect(options.configured_aggregator)
+            .to be(aggregator)
+        end
+      end
+    end
+
+    context 'when aggregator is a String' do
+      let(:aggregator)      { "Magicka::#{aggregator_name}" }
+      let(:aggregator_name) { :CustomAggregator }
+
+      before { Magicka.const_set(aggregator_name, aggregator_class) }
+
+      context 'when config block is given' do
+        let(:aggregator_name) { :CustomAggregator1 }
+
+        it 'returns the given aggregator class' do
+          expect(options.configured_aggregator)
+            .to be(aggregator_class)
+        end
+      end
+
+      context 'when config block is given and is called' do
+        let(:aggregator_name) { :CustomAggregator2 }
+
+        it 'configure the aggregator' do
+          options.configured_aggregator.new(renderer, model)
+                 .input(:name)
+
+          expect(element_class).to have_received(:render)
+        end
+      end
+
+      context 'when config block is not given' do
+        let(:aggregator_name) { :CustomAggregator3 }
+        let(:config_block) { nil }
+
+        it 'returns the given aggregator class' do
+          expect(options.configured_aggregator)
+            .to be(aggregator_class)
+        end
+      end
+    end
+  end
+end