super_form 0.0.1 → 0.1.0

data/spec/lib/field/form_array_spec.rb

@@ -0,0 +1,71 @@
+require 'super_form'
+require 'spec_helper'
+
+describe Field::FormArray do
+  context 'when creating a form collection field' do
+    it 'assigns an array of child forms to the field attribute' do
+      child_form = Class.new { include SuperForm }
+
+      field = Field::FormArray.new(:fake)
+      field.form_class = child_form
+
+      expect(field.attribute).to eq Array[child_form]
+    end
+  end
+
+  context 'when the form field has a container' do
+    before do
+      @child_form = Class.new do
+        include SuperForm
+
+        field :name, Field::Text, presence: true
+      end
+
+      parent_form = Class.new { include SuperForm }
+
+      field = Field::FormArray.new(:child_form)
+      field.form_class = @child_form
+      field.setup_container(parent_form)
+
+      @parent_form = parent_form.new
+    end
+
+    describe '#inject_attributes' do
+      it 'injects attributes into the parent form' do
+        expect(@parent_form).to respond_to :child_form=
+        expect(@parent_form).to respond_to :child_form
+        expect(@parent_form.child_form).to eq []
+      end
+    end
+
+    describe '#inject validations' do
+      it 'forces the parent object to validate the child object' do
+        @parent_form.child_form = [@child_form.new, @child_form.new, @child_form.new]
+        @parent_form.save
+        errors = [
+          'Invalid child_form on row 1',
+          'Invalid child_form on row 2',
+          'Invalid child_form on row 3'
+        ]
+        expect(@parent_form.errors[:base]).to eq(errors)
+      end
+    end
+  end
+
+  describe '#[]' do
+    before do
+      @child_form = Class.new { include SuperForm }
+      proxy = Field::FormArray[@child_form]
+
+      @field = proxy.factory(:name)
+    end
+
+    it 'creates a form instance' do
+      expect(@field).to be_instance_of(Field::FormArray)
+    end
+
+    it 'stores the child form into the form_class attribute' do
+      expect(@field.form_class).to eq @child_form
+    end
+  end
+end

data/spec/lib/field/form_spec.rb

@@ -0,0 +1,68 @@
+require 'super_form'
+require 'spec_helper'
+
+describe Field::Form do
+  context 'when creating a form field isolatedly' do
+    it 'assigns the child form to the field attribute' do
+      child_form = Class.new { include SuperForm }
+
+      field = Field::Form.new(:fake)
+      field.form_class = child_form
+
+      expect(field.attribute).to eq child_form
+    end
+  end
+
+  context 'when the form field has a container' do
+    before do
+      @child_form = Class.new do
+        include SuperForm
+
+        field :name, Field::Text, presence: true
+      end
+
+      parent_form = Class.new { include SuperForm }
+
+      field = Field::Form.new(:child_form)
+      field.form_class = @child_form
+      field.setup_container(parent_form)
+
+      @parent_form = parent_form.new
+    end
+
+    describe '#inject_attributes' do
+      it 'injects virtus attributes into the parent form' do
+        expect(@parent_form).to respond_to :child_form=
+        expect(@parent_form).to respond_to :child_form
+      end
+
+      it 'returns an instance of child form as the default value' do
+        expect(@parent_form.child_form).to be_instance_of(@child_form)
+      end
+    end
+
+    describe '#inject validations' do
+      it 'forces the parent object to validate the child object' do
+        @parent_form.save
+        expect(@parent_form.errors[:base]).to eq(['Invalid child_form'])
+      end
+    end
+  end
+
+  describe '#[]' do
+    before do
+      @child_form = Class.new { include SuperForm }
+      proxy = Field::Form[@child_form]
+
+      @field = proxy.factory(:name)
+    end
+
+    it 'creates a form instance' do
+      expect(@field).to be_instance_of(Field::Form)
+    end
+
+    it 'stores the child form into the form_class attribute' do
+      expect(@field.form_class).to eq @child_form
+    end
+  end
+end

data/spec/lib/field_spec.rb

@@ -0,0 +1,13 @@
+require 'field'
+
+describe Field::Base do
+  it 'responds to presenter_class' do
+    field = Field::Base.new(:fake)
+    expect(field).to respond_to :presenter_class
+  end
+
+  it 'presenter_class returns nil by default' do
+    field = Field::Base.new(:fake)
+    expect(field.presenter_class).to be_nil
+  end
+end

data/spec/lib/person_type_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'person_type'
+
+describe PersonType do
+  describe '#valid?' do
+    it "returns false when person type is invalid" do
+      invalid_values = %w{one two three four 3244}
+
+      invalid_values.each do |value|
+        person = PersonType.new(value)
+        expect(person).to_not be_valid
+      end
+    end
+
+    it "returns true when person type is valid" do
+      valid_values = [PersonType::NATURAL, PersonType::LEGAL]
+
+      valid_values.each do |value|
+        person = PersonType.new(value)
+        expect(person).to be_valid
+      end
+    end
+  end
+
+  describe "#value" do
+    context "with a valid value" do
+      it "returns the value" do
+        person = PersonType.new(PersonType::LEGAL)
+        expect(person.value).to eq PersonType::LEGAL
+      end
+    end
+
+    context "with an invalid value" do
+      it "returns nil" do
+        person = PersonType.new('bossal')
+        expect(person.value).to be_nil
+      end
+    end
+  end
+
+  describe '#description' do
+    it 'returns "Natural person" when value is "natural"' do
+      person = PersonType.new(PersonType::NATURAL)
+      expect(person.description).to eq 'Natural person'
+    end
+
+    it 'returns "Legal entity" when value is "legal"' do
+      person = PersonType.new(PersonType::LEGAL)
+      expect(person.description).to eq 'Legal entity'
+    end
+
+    it 'returns a default description otherwise' do
+      person = PersonType.new('bossal')
+      expect(person.description('Bossal')).to eq 'Bossal'
+    end
+  end
+
+  describe '.to_collection' do
+    it "returns an array with the collection" do
+      expect(PersonType.to_collection).to eq [
+        ['Natural person', PersonType::NATURAL],
+        ['Legal entity',   PersonType::LEGAL],
+      ]
+    end
+  end
+end

data/spec/lib/presenter/cnpj_spec.rb

@@ -0,0 +1,9 @@
+require 'presenter'
+
+describe Presenter::CNPJ do
+  it 'outputs a formatted CNPJ' do
+    presenter = Presenter::CNPJ.new('79371223118469')
+    cnpj = CNPJ.new('79371223118469')
+    expect(presenter.output).to eq(cnpj.formatted)
+  end
+end

data/spec/lib/presenter/cpf_spec.rb

@@ -0,0 +1,9 @@
+require 'presenter'
+
+describe Presenter::CPF do
+  it 'outputs a formatted CPF' do
+    presenter = Presenter::CPF.new('47788423165')
+    cpf = CPF.new('47788423165')
+    expect(presenter.output).to eq(cpf.formatted)
+  end
+end

data/spec/lib/presenter/form_spec.rb

@@ -0,0 +1,39 @@
+require 'super_form'
+require 'presenter'
+
+describe Presenter::Form do
+  it 'outputs each field according to its defined presenter class' do
+    field_class_with_presenter_class = Class.new(Field::Base) do
+      def presenter_class
+        Class.new(Presenter::Each) do
+          def self.__name__
+            'anonymous'
+          end
+
+          def output
+            'formatted output'
+          end
+        end
+      end
+    end
+
+    field_class_without_presenter_class = Class.new(Field::Base)
+
+    form_class = Class.new do
+      include SuperForm
+
+      add_field(field_class_with_presenter_class.new(:with_presenter))
+      add_field(field_class_without_presenter_class.new(:without_presenter))
+    end
+
+    form = form_class.new(
+      with_presenter:    'unformatted output',
+      without_presenter: 'unformattable'
+    )
+
+    presenter = Presenter::Form.factory(form)
+
+    expect(presenter.with_presenter).to eq('formatted output')
+    expect(presenter.without_presenter).to eq('unformattable')
+  end
+end

data/spec/lib/presenter/password_spec.rb

@@ -0,0 +1,8 @@
+require 'presenter'
+
+describe Presenter::Password do
+  it 'outputs nil' do
+    presenter = Presenter::Password.new('secret')
+    expect(presenter.output).to eq nil
+  end
+end

data/spec/lib/presenter/person_type_spec.rb

@@ -0,0 +1,8 @@
+describe Presenter::PersonType do
+  it 'outputs the person type description' do
+    person = PersonType.new(PersonType::LEGAL)
+    presenter = Presenter::PersonType.new(PersonType::LEGAL)
+
+    expect(presenter.output).to eq person.description
+  end
+end

data/spec/lib/presenter/telephone_spec.rb

@@ -0,0 +1,9 @@
+require 'presenter'
+
+describe Presenter::Telephone do
+  it 'outputs a formatted phone' do
+    presenter = Presenter::Telephone.new('8811111111')
+    phone = Telephone.new('8811111111')
+    expect(presenter.output).to eq(phone.formatted)
+  end
+end

data/spec/lib/presenter_spec.rb

@@ -0,0 +1,166 @@
+require 'presenter'
+require File.expand_path('../../support/presenter_name', __FILE__)
+
+module Presenter
+  describe Base do
+    it_behaves_like 'presenter nameable'
+
+    describe 'delegates to the source object' do
+      it 'calls the source object correspondent methods' do
+        source = stub_source_object([:name, :phone])
+        presenter = Base.new(source)
+
+        expect(source).to receive(:name)
+        expect(source).to receive(:phone)
+
+        presenter.name
+        presenter.phone
+      end
+
+      it 'returns the same values as the source object' do
+        source = stub_source_object([:name, :phone])
+        presenter = Base.new(source)
+
+        expect(presenter.name).to eq (source.name)
+        expect(presenter.phone).to eq (source.phone)
+      end
+    end
+
+    describe '.map' do
+      context 'with one mapping specified' do
+        it 'assigns specified attribute to specified "each presenter"' do
+          presenter = stub_presenter(:inexistent) { map :inexistent => :fake }
+          fake_presenter = stub_each_presenter(:fake, presenter)
+
+          expect(presenter.inexistent).to eq fake_presenter.output
+        end
+      end
+
+      context 'with multiple mappings specified' do
+        it 'assigns specified attributes to specified "each presenters"' do
+          presenter = stub_presenter(:inexistent, :power) do
+            map :inexistent => :fake, :power => :chord
+          end
+
+          fake = stub_each_presenter(:fake, presenter)
+          chord = stub_each_presenter(:chord, presenter)
+
+          expect(presenter.inexistent).to eq fake.output
+          expect(presenter.power).to eq chord.output
+        end
+      end
+
+      it 'tries to guess the presenter when no presenter is assigned' do
+        presenter = stub_presenter(:something) { map :something => :fake }
+
+        class Fake < Each
+          def output
+            '123456'
+          end
+        end
+
+        expect(presenter.something).to eq('123456')
+      end
+    end
+
+    describe '.use' do
+      context 'with one presenter specified' do
+        it 'uses one presenter' do
+          presenter = stub_presenter(:inexistent) { use :inexistent }
+          inexistent = stub_each_presenter(:inexistent, presenter)
+
+          expect(presenter.inexistent).to eq inexistent.output
+        end
+      end
+
+      context 'with multiple presenters specified' do
+        it 'uses multiple presenters' do
+          presenter = stub_presenter(:inexistent, :fake) do
+            use :inexistent, :fake
+          end
+
+          inexistent = stub_each_presenter(:inexistent, presenter)
+          fake = stub_each_presenter(:fake, presenter)
+
+          expect(presenter.inexistent).to eq inexistent.output
+          expect(presenter.fake).to eq fake.output
+        end
+      end
+
+      it 'tries to guess the presenter when no presenter is assigned' do
+        presenter = stub_presenter(:inexistent) { use :inexistent }
+
+        class Inexistent < Each
+          def output
+            '12345'
+          end
+        end
+
+        expect(presenter.inexistent).to eq('12345')
+      end
+
+      it 'works if given a presenter class instead of a symbol' do
+        each_presenter = Class.new(Each) do
+          def self.__name__
+            'fake'
+          end
+
+          def output
+            'it works'
+          end
+        end
+
+        presenter = stub_presenter(:fake) { map :fake => each_presenter }
+        expect(presenter.fake).to eq('it works')
+      end
+    end
+  end
+
+  describe Each do
+    it_behaves_like 'presenter nameable'
+
+    it 'can access the raw value' do
+      presenter = Each.new('some value')
+      expect(presenter.value).to eq('some value')
+    end
+
+    it 'outputs the raw value by default' do
+      presenter = Each.new('some value')
+      expect(presenter.output).to eq(presenter.value)
+    end
+
+    it 'delegates to :output when :to_s is called' do
+      presenter = Each.new('some value')
+      expect(presenter.to_s).to eq(presenter.output)
+    end
+  end
+end
+
+def stub_source_object(params)
+  source = Object.new
+
+  Array(params).each do |p|
+    source.stub(p).and_return(p.to_s)
+  end
+
+  source
+end
+
+def stub_presenter(*source_params, &block)
+  source = stub_source_object(source_params)
+  Class.new(Presenter::Base, &block).new(source)
+end
+
+def stub_each_presenter(id, presenter = nil)
+  each_presenter = Class.new(Presenter::Each) do
+    def output
+      'output'
+    end
+  end.new
+
+  if presenter
+    presenter.send("#{id}_presenter=", each_presenter)
+  end
+
+  each_presenter
+end