super_form 0.0.1 → 0.1.0

data/lib/presenter/cnpj.rb

@@ -0,0 +1,9 @@
+require 'cnpj'
+
+module Presenter
+  class CNPJ < Each
+    def output
+      ::CNPJ.new(value).formatted
+    end
+  end
+end

data/lib/presenter/cpf.rb

@@ -0,0 +1,9 @@
+require 'cpf'
+
+module Presenter
+  class CPF < Each
+    def output
+      ::CPF.new(value).formatted
+    end
+  end
+end

data/lib/presenter/form.rb

@@ -0,0 +1,20 @@
+module Presenter
+  class Form < Base
+    def self.factory(form)
+      presenters = form.fields.each_with_object({}) do |field, p|
+        name, field = field
+        p[name] = field.presenter_class if field.presenter_class
+      end
+
+      presenter_class = Class.new(Base) do
+        map presenters
+
+        def self.__name__
+          'form'
+        end
+      end
+
+      presenter_class.new(form)
+    end
+  end
+end

data/lib/presenter/password.rb

@@ -0,0 +1,7 @@
+module Presenter
+  class Password < Each
+    def output
+      nil
+    end
+  end
+end

data/lib/presenter/person_type.rb

@@ -0,0 +1,9 @@
+require 'person_type'
+
+module Presenter
+  class PersonType < Each
+    def output
+      ::PersonType.new(value).description
+    end
+  end
+end

data/lib/presenter/telephone.rb

@@ -0,0 +1,9 @@
+require 'telephone'
+
+module Presenter
+  class Telephone < Each
+    def output
+      ::Telephone.new(value).formatted
+    end
+  end
+end

data/lib/super_form.rb

@@ -1,39 +1,23 @@
-require "super_form/version"
-
-require 'field'
-require 'attribute'
-require 'virtus'
-require 'active_support/inflector'
 require 'active_support/concern'
-require 'active_model'
+require 'virtus'
+require 'super_form/fieldable'
+require "super_form/version"
 
 autoload :UniquenessValidator, 'uniqueness_validator'
 
 module SuperForm
-  def self.included(klass)
-    virtus = if @virtus_options
-      Virtus.model(@virtus_options)
-    else
-      Virtus.model
-    end
-
-    klass.include virtus
-    klass.include ActiveModel::Conversion
-    klass.include ActiveModel::Validations
-    klass.extend  ActiveModel::Naming
-    klass.extend  ActiveModel::Callbacks
-    klass.extend  ClassMethods
+  extend ActiveSupport::Concern
+  include Fieldable
 
-    add_callbacks(klass)
-    add_constructor(klass)
+  included do
+    include Virtus.model
 
-    klass.send(:attr_reader, :fieldsets)
-
-    @virtus_options = nil
+    class_eval &SuperForm.callbacks
+    class_eval &SuperForm.constructor
   end
 
-  def self.add_constructor(klass)
-    klass.class_eval do
+  def self.constructor
+    Proc.new do
       alias_method :original_initializer, :initialize
 
       def initialize(*args)
@@ -43,8 +27,8 @@ module SuperForm
     end
   end
 
-  def self.add_callbacks(klass)
-    klass.class_eval do
+  def self.callbacks
+    Proc.new do
       alias_method :ar_valid?, :valid?
 
       def valid?
@@ -57,40 +41,16 @@ module SuperForm
     end
   end
 
-  def self.base(virtus_options = {})
-    @virtus_options = virtus_options
-    Form
-  end
-
   def setup
-    initialize_fields
-    instance_eval(&self.class.setup) if self.class.setup
+    if self.class.setup
+      instance_eval(&self.class.setup)
+    end
   end
 
   def persisted?
     false
   end
 
-  def fields
-    @fields
-  end
-
-  def field(name)
-    if self.class.form?(name)
-      send(name)
-    else
-      @fields.fetch(name)
-    end
-  end
-
-  def form?
-    true
-  end
-
-  def form_label
-    self.class.name.to_s.gsub(/Form$/, '').humanize
-  end
-
   def save
     if valid?
       run_callbacks :save do
@@ -102,25 +62,9 @@ module SuperForm
     end
   end
 
-  private
-
-  def initialize_fields
-    @fields = {}
-    @fieldsets = {}
+  def persist!; end
 
-    # take care of branches here
-    self.class.fields.each do |id, field|
-      if self.class.form?(id)
-        @fields[id] = field
-
-        fieldset = self.class.child_form_fieldsets[id]
-        (@fieldsets[fieldset] ||= []) << @fields[id]
-      else
-        @fields[id] = field.dup
-        (@fieldsets[field.fieldset] ||= []) << @fields[id]
-      end
-    end
-  end
+  private
 
   module ClassMethods
     def setup(&block)
@@ -128,88 +72,9 @@ module SuperForm
       @setup
     end
 
-    def form?(field_id = nil)
-      field_id.nil? ? true : child_form_fieldsets.has_key?(field_id)
-    end
-
-    # fieldset may be extracted as a domain object
-    def fieldset(id)
-      initialize_fieldset(id)
-      yield
-      close_fieldset
-    end
-
-    def child_form_fieldsets
-      @child_form_fieldsets ||= {}
-    end
-
-    # take care of branches here
-    def field(name, field_class, options = {})
-      if field_class.ancestors.include? SuperForm
-        child_form_fieldsets[name] = current_fieldset_name
-        attribute name, field_class
-
-        define_method(name) do
-          var   = :"@#{name.to_s}"
-          value = instance_variable_get(var)
-
-          unless value
-            value = instance_variable_set(var, field_class.new)
-          end
-
-          value
-        end
-
-        create_child_validation(name)
-        field = name
-      else
-        field = field_class.new(name, current_fieldset_name)
-
-        field.add_validations(self, options)
-        field.add_attributes(self, options)
-
-        alias_method :"original_#{name.to_s}=", "#{name}="
-
-        define_method "#{name}=" do |value|
-          field = self.field(name)
-          field.value = value if field
-
-          send "original_#{name.to_s}=", value
-        end
-      end
-
-      fields[name] = field
-    end
-
-    def fields
-      @fields ||= {}
-    end
-
-    private
-
-    def initialize_fieldset(id)
-      @current = id
-    end
-
-    def close_fieldset
-      @current = nil
-    end
-
-    def current_fieldset_name
-      @current ||= default_fieldset_name
-    end
-
-    def default_fieldset_name
-      :general
-    end
-
-    def create_child_validation(name)
-      validate :"ensure_valid_#{name.to_s}"
-
-      define_method "ensure_valid_#{name.to_s}" do
-        unless send(name).send(:valid?)
-          errors.add(:base, "Invalid #{name.to_s}")
-        end
+    def model_name
+      if name = self.name || self.to_s
+        ActiveModel::Name.new(self, nil, name.gsub(/Form$/, ''))
       end
     end
   end

data/lib/super_form/fieldable.rb

@@ -0,0 +1,78 @@
+require 'active_support/concern'
+require 'active_model'
+require 'field'
+
+module SuperForm
+  module Fieldable
+    extend ActiveSupport::Concern
+    include ActiveModel::Model
+
+    def fields
+      @fields ||= self.class.fields.each_with_object({}) do |field, f|
+        f[field.name] = field.dup
+        f[field.name].form = self
+      end
+    end
+
+    def field(name)
+      fields.fetch(name)
+    end
+
+    def fieldsets
+      @fieldsets ||= self.class.fieldsets.each_with_object({}) do |fieldset, f|
+        id, fields = fieldset
+
+        fields.each_with_object(f) do |field|
+          (f[id] ||= Fieldset.new(id)) << self.field(field)
+        end
+      end
+    end
+
+    def fieldset(id)
+      fieldsets.fetch(id)
+    end
+
+    module ClassMethods
+      def field(field_id, field_class, options = {})
+        field = field_class.factory(field_id, options)
+        add_field(field)
+      end
+
+      def fields
+        @fields ||= []
+      end
+
+      def fieldset(id)
+        open_fieldset(id)
+        yield
+        close_fieldset
+      end
+
+      def fieldsets
+        @fieldsets ||= {}
+      end
+
+      private
+
+      def add_field(field)
+        field.setup_container(self)
+
+        fields << field
+        current_fieldset << field.name
+      end
+
+      def open_fieldset(id)
+        @current = id
+        fieldsets[@current] ||= []
+      end
+
+      def close_fieldset
+        @current = nil
+      end
+
+      def current_fieldset
+        fieldsets[@current] || open_fieldset(:default)
+      end
+    end
+  end
+end

data/lib/super_form/fieldset.rb

@@ -0,0 +1,32 @@
+module SuperForm
+  class Fieldset
+    include Enumerable
+
+    attr_reader :id, :fields
+
+    def initialize(id)
+      @id     = id
+      @fields = {}
+    end
+
+    def add_field(field)
+      @fields[field.name] = field
+    end
+
+    def <<(field)
+      add_field(field)
+    end
+
+    def field(field_id)
+      @fields[field_id]
+    end
+
+    def [](field_id)
+      field(field_id)
+    end
+
+    def each(&block)
+      @fields.each { |field_id| block.call(field_id) }
+    end
+  end
+end

data/lib/super_form/version.rb

@@ -1,3 +1,3 @@
 module SuperForm
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/lib/field/form_array.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