populate-me 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a4e1b29c84ee80302c1e0dc749c0de5926191c1
-  data.tar.gz: a600a41a3590d08d0a09f429fd65bded993f12cb
+  metadata.gz: c47e2bdae6fcc97d34ec729a23107c4d7af9069d
+  data.tar.gz: 60b764c3d31de7c5c5853a1d2eec72af7404e80e
 SHA512:
-  metadata.gz: 22131a127100872095a3c1c5f8188f75a18bb5913c6d0611d4ad897a0013edaf09a0e1b9463384025d70e675933ca511b9f4135d4d4ce6f8c34123ae4db63aa0
-  data.tar.gz: aac7ae50254aa787daaf7d83c10955a251483823cfc9f5f9d512777ecd95d2ba1ac134776cb7697c5b9b2d9a71451769e3faeaf14550af71b0f2f49de945da42
+  metadata.gz: 563cb8b28cce6d5364b0e7588b2feaadeb472facec7127de93d14b7a64a34b81a17e66b7d819bceee5f7f785b40cbc7e205ec213817532612295b2bbade91f99
+  data.tar.gz: cf7f5c53a887d2cee9b64aee30f85125588fe8f16cdf2edd358acf05eb6f39f12e0113c3e5759b951d9b96b10f8a60b18b00d659f500e914af6d93cc38493e5f

data/README.md

@@ -15,12 +15,13 @@ Table of contents
 - [Table of contents](#table-of-contents)
 - [Documents](#documents)
   - [Schema](#schema)
-  - [Validations](#validations)
   - [Relationships](#relationships)
+  - [Validations](#validations)
   - [Callbacks](#callbacks)
   - [Single Documents](#single-documents)
   - [Mongo documents](#mongo-documents)
 - [Admin](#admin)
+  - [Polymorphism](#polymorphism)
   - [Customize Admin](#customize-admin)
 - [API](#api)
 
@@ -67,6 +68,7 @@ itself, but here are the keys used by `PopulateMe`:
 - `:wrap` Set it to false if you do not want the form field to be wrapped in a `div` with a label.
 - `:default` Either a default value or a `proc` to run to get the default value.
 - `:required` Set to true if you want the field to be marked as required in the form.
+- `:only_for` List of polymorphic type values
 
 As you can see, most of the options are made for you to tailor the form
 which `PopulateMe` will generate for you in the admin.
@@ -88,33 +90,6 @@ blog_article.published # Returns true or false
 blog_article.published = true
 ```
 
-### Validations
-
-In its simplest form, validations are done by overriding the `#validate` method and declaring errors with the `#error_on` method.
-
-```ruby
-class Person < PopulateMe::Document
-  
-  field :name
-
-  def validate
-    error_on(:name, 'Cannot be fake') if self.name=='John Doe'
-  end
-
-end
-```
-
-If you don't use the `PopulateMe` interface and create a document
-programmatically, here is what it could look like:
-
-```ruby
-person = Person.new(name: 'John Doe')
-person.new? # returns true
-person.save # fails
-person.valid? # returns false
-person.errors # returns { name: ['Cannot be fake'] }
-```
-
 ### Relationships
 
 In its simplest form, when using the modules convention, relationships
@@ -151,6 +126,33 @@ It uses the `PopulateMe::Document::admin_find` and
 `PopulateMe::Document::admin_find_first` methods in the background, 
 so default sorting order is respected.
 
+### Validations
+
+In its simplest form, validations are done by overriding the `#validate` method and declaring errors with the `#error_on` method.
+
+```ruby
+class Person < PopulateMe::Document
+  
+  field :name
+
+  def validate
+    error_on(:name, 'Cannot be fake') if self.name=='John Doe'
+  end
+
+end
+```
+
+If you don't use the `PopulateMe` interface and create a document
+programmatically, here is what it could look like:
+
+```ruby
+person = Person.new(name: 'John Doe')
+person.new? # returns true
+person.save # fails
+person.valid? # returns false
+person.errors # returns { name: ['Cannot be fake'] }
+```
+
 ### Callbacks
 
 There are some classic hooks which trigger the callbacks you declare.
@@ -404,6 +406,131 @@ probably for [single documents](#single-documents) because they are not part of
 a list. The ID would then be litterally `unique`, or whatever ID you declared
 instead.
 
+### Polymorphism
+
+You can use the schema to set a Document class as polymorphic. The consequence 
+is that the admin will make you choose a type before creating a new document. 
+And then the form will only display the fields applicable to this polymorphic 
+type. And once created, it will only show relationships applicable to its 
+polymorphic type. You can do this with the `:only_for` option.
+
+Here is an example of a document that can either be a title with a paragraph, or
+a title with a set of images:
+
+```ruby
+# lib/models/box.rb
+
+require 'populate_me/document'
+
+class Box < PopulateMe::Document
+
+  field :title
+  field :paragraph, type: :text, only_for: 'Paragraph'
+  relationship :images, only_for: 'Image slider'
+  position_field
+
+end
+```
+
+In this case, when you create a `Box` with the polymorphic type `Paragraph`, the
+form will have a field for `:paragraph` but no relationship for images. And if 
+you create a `Box` with the polymorphic type `Image slider`, it will be the 
+opposite.
+
+The option `:only_for` can also be an `Array`. Actually, when inspecting the 
+`fields`, you'll see that even when you pass a `String`, it will be put inside 
+an `Array`.
+
+```ruby
+Box.fields[:paragraph][:only_for] # => ['Paragraph']
+```
+
+A hidden field is automatically created called `:polymorphic_type`, therefore 
+it is a method you can call to get or set the `:polymorphic_type`.
+
+```ruby
+box = Box.new polymorphic_type: 'Paragraph'
+box.polymorphic_type # => 'Paragraph'
+```
+
+One of the information that the field contains is all the `:values` the field 
+can have.
+
+```ruby
+Box.fields[:polymorphic_type][:values] # => ['Paragraph', 'Image slider']
+```
+
+They are in the order they are declared in the fields. If you want to just set 
+this list yourself or any other option attached to the `:polimorphic_type` field 
+you can do so with the `Document::polymorphic` class method.
+
+```ruby
+# lib/models/box.rb
+
+require 'populate_me/document'
+
+class Box < PopulateMe::Document
+
+  polymorphic values: ['Image slider', 'Paragraph']
+  field :title
+  field :paragraph, type: :text, only_for: 'Paragraph'
+  relationship :images, only_for: 'Image slider'
+  position_field
+
+end
+```
+
+If each polymorphic type has a lot of fields and/or relationships, you can use the 
+`Document::only_for` class method which sets the `:only_for` option for 
+everything inside the block.
+
+```ruby
+# lib/models/media.rb
+
+require 'populate_me/document'
+
+class Media < PopulateMe::Document
+  
+  field :title
+  only_for 'Book' do
+    field :author
+    field :publisher
+    relationship :chapters
+  end
+  only_for 'Movie' do
+    field :script_writer
+    field :director
+    relationship :scenes
+    relationship :actors
+  end
+  position_field
+
+end
+```
+
+It is worth noting that this implementation of polymorphism is supposed to work 
+with fixed schema databases, and therefore all fields and relationship exist for 
+each document. In our case, books would still have a `#director` method. The 
+difference is only cosmetic and mainly allows you to have forms that are less 
+crowded in the admin.
+
+To mitigate this, a few methods are there to help you. There is a predicate for 
+knowing if a class is polymorphic.
+
+```ruby
+Media.polymorphic? # => true
+```
+
+For each document, you can inspect its polymorphic type or check if a field or 
+relationship is applicable.
+
+```ruby
+book = Media.new polymorphic_type: 'Book', title: 'Hot Water Music', author: 'Charles Bukowski'
+book.polymorphic_type # => 'Book'
+book.field_applicable? :author # => true
+book.relationship_applicable? :actors # => false
+```
+
 ### Customize Admin
 
 You can customize the admin with a few settings. 

data/example/config.ru

@@ -65,11 +65,22 @@ class Article < PopulateMe::Document
   field :price, type: :price
   position_field
 
+  relationship :sections
+
   after :save do
     puts self.inspect
   end
 end
 
+class Article::Section < PopulateMe::Document
+
+  field :short, only_for: 'Nice Short'
+  field :long, only_for: 'Nice Long'
+  field :article_id, type: :hidden
+  position_field scope: :article_id
+
+end
+
 # Admin ##########
 
 require "populate_me/admin"

data/lib/populate_me/admin/__assets__/css/main.css

@@ -60,6 +60,10 @@ button { cursor: pointer; }
 
 /* Lists */
 
+.new-document-btn-wrap > * {
+  vertical-align: middle;
+}
+
 .new-document-btn, .new-nested-document-btn {
   border: 0;
   font-size: 1.615em;

data/lib/populate_me/admin/__assets__/js/main.js

@@ -30,6 +30,19 @@ PopulateMe.display_file_size = function(size) {
   return size+unit;
 };
 
+// Add or update query string parameter on a URI
+PopulateMe.update_query_parameter = function(uri, key, value) {
+  var sane_key = key.replace(/[\[\]]/g, "\\$&");
+  var re = new RegExp("([?&])" + sane_key + "=.*?(&|$)", "i");
+  var separator = uri.indexOf('?') !== -1 ? "&" : "?";
+  if (uri.match(re)) {
+    return uri.replace(re, '$1' + key + "=" + encodeURIComponent(value) + '$2');
+  }
+  else {
+    return uri + separator + key + "=" + encodeURIComponent(value);
+  }
+};
+
 // Template helpers
 PopulateMe.template_helpers = {
   custom_partial_or_default: function() {
@@ -180,7 +193,14 @@ PopulateMe.init_column = function(c) {
   $('textarea',c).trigger('input');
 
   // Init multiple select with asmSelect
-  $('select[multiple]').asmSelect({ sortable: true, removeLabel: '×' });
+  $('select[multiple]', c).asmSelect({ sortable: true, removeLabel: '×' });
+
+  // Polymorphic selector
+  $('select.polymorphic_type_values').change(function() {
+    var $this = $(this);
+    var link = $this.next();
+    link.attr('href', PopulateMe.update_query_parameter(link.attr('href'), 'data[polymorphic_type]', $this.val()));
+  }).change();
 
   // Possible callback from custom javascript file.
   // If you need to do something on init_column,

data/lib/populate_me/admin/views/page.erb

@@ -36,6 +36,14 @@
         {{page_title}}
       </h1>
       <p class='new-document-btn-wrap'>
+        {{#is_polymorphic}}
+          <select class='polymorphic_type_values'>
+            {{#polymorphic_type_values}}
+              <option value='{{.}}'>{{.}}</option>
+            {{/polymorphic_type_values}}
+          </select>
+          &nbsp;
+        {{/is_polymorphic}}
         <a href="<%= request.script_name %>/form/{{dasherized_class_name}}{{#new_data}}?{{new_data}}{{/new_data}}" class='column-push new-document-btn' title='Create'>+</a>
       </p>
       <ol class='documents' data-sort-field='{{sort_field}}' data-sort-url='<%= request.script_name %>/api/{{dasherized_class_name}}'>
@@ -65,6 +73,9 @@
 
     <script id="template-form" type="x-tmpl-mustache">
       <h1>{{page_title}}</h1>
+      {{#polymorphic_type}}
+        <p>({{polymorphic_type}})</p>
+      {{/polymorphic_type}}
       <form action="<%= request.script_name %>/api/{{admin_url}}" method="POST" accept-charset="utf-8" class='admin-{{#is_new}}post{{/is_new}}{{^is_new}}put{{/is_new}}'>
         {{#custom_partial_or_default}}template_form_fields{{/custom_partial_or_default}}
         {{^is_new}}

data/lib/populate_me/document.rb

@@ -88,9 +88,10 @@ module PopulateMe
     end
 
     def to_s
-      return inspect if self.class.label_field.nil?
-      me = self.__send__(self.class.label_field)
-      WebUtils.blank?(me) ? inspect : me
+      default = "#{self.class}#{' ' unless WebUtils.blank?(self.id)}#{self.id}"
+      return default if self.class.label_field.nil?
+      me = self.__send__(self.class.label_field).dup
+      WebUtils.blank?(me) ? default : me
     end
 
     def new?; self._is_new; end

data/lib/populate_me/document_mixins/admin_adapter.rb

@@ -20,14 +20,14 @@ module PopulateMe
           title: WebUtils.truncate(to_s, 60),
           image_url: admin_image_url,
           local_menu: self.class.relationships.inject([]) do |out,(k,v)|
-            unless v[:hidden]
+            if not v[:hidden] and self.relationship_applicable?(k)
               out << {
                 title: "#{v[:label]}",
                 href: "#{o[:request].script_name}/list/#{WebUtils.dasherize_class_name(v[:class_name])}?filter[#{v[:foreign_key]}]=#{self.id}",
                 new_page: false 
               }
-              out
             end
+            out
           end
         }
       end
@@ -41,16 +41,19 @@ module PopulateMe
         }
         self.class.complete_field_options :_class, class_item
         items = self.class.fields.inject([class_item]) do |out,(k,item)|
-          if item[:form_field]
+          if item[:form_field] and self.field_applicable?(k)
             out << outcast(k, item, o)
           end
           out
         end
+        page_title = self.new? ? "New #{self.class.to_s_short}" : self.to_s
+        # page_title << " (#{self.polymorphic_type})" if self.class.polymorphic?
         {
           template: "template#{'_nested' if o[:nested]}_form",
-          page_title: self.new? ? "New #{self.class.to_s_short}" : self.to_s,
+          page_title: page_title,
           admin_url: self.to_admin_url,
           is_new: self.new?,
+          polymorphic_type: self.class.polymorphic? ? self.polymorphic_type : nil,
           fields: items
         }
       end
@@ -121,6 +124,8 @@ module PopulateMe
             page_title: self.to_s_short_plural,
             dasherized_class_name: WebUtils.dasherize_class_name(self.name),
             new_data: new_data,
+            is_polymorphic: self.polymorphic?,
+            polymorphic_type_values: self.polymorphic? ? self.fields[:polymorphic_type][:values] : nil,
             sort_field: self.sort_field_for(o),
             # 'command_plus'=> !self.populate_config[:no_plus],
             # 'command_search'=> !self.populate_config[:no_search],

data/lib/populate_me/document_mixins/schema.rb

@@ -14,7 +14,7 @@ module PopulateMe
         def fields; @fields ||= {}; end
 
         def field name, o={}
-          set_id_field if self.fields.empty?&&o[:type]!=:id
+          set_id_field if self.fields.empty? and o[:type]!=:id
           complete_field_options name, o
           if o[:type]==:list
             define_method(name) do
@@ -34,6 +34,9 @@ module PopulateMe
           o[:wrap] = false unless o[:form_field]
           WebUtils.ensure_key! o, :wrap, ![:hidden,:list].include?(o[:type])
           WebUtils.ensure_key! o, :label, WebUtils.label_for_field(name)
+          unless [:id, :polymorphic_type].include?(o[:type])
+            complete_only_for_field_option o
+          end
           if o[:type]==:attachment
             WebUtils.ensure_key! o, :class_name, settings.default_attachment_class
             raise MissingAttachmentClassError, "No attachment class was provided for the #{self.name} field: #{name}" if o[:class_name].nil?
@@ -51,6 +54,20 @@ module PopulateMe
           end
         end
 
+        def complete_only_for_field_option o={}
+          if @currently_only_for
+            o[:only_for] = @currently_only_for
+          end
+          if o[:only_for].is_a?(String)
+            o[:only_for] = [o[:only_for]]
+          end
+          if o.key?(:only_for)
+            self.polymorphic unless self.polymorphic?
+            self.fields[:polymorphic_type][:values] += o[:only_for]
+            self.fields[:polymorphic_type][:values].uniq!
+          end
+        end
+
         def set_id_field
           field :id, {type: :id}
         end
@@ -62,12 +79,51 @@ module PopulateMe
           sort_by name, (o[:direction]||:asc)
         end
 
+        def polymorphic o={}
+          WebUtils.ensure_key! o, :type, :polymorphic_type
+          WebUtils.ensure_key! o, :values, []
+          WebUtils.ensure_key! o, :wrap, false
+          WebUtils.ensure_key! o, :input_attributes, {}
+          WebUtils.ensure_key! o[:input_attributes], :type, :hidden
+          field(:polymorphic_type, o) unless self.polymorphic?
+        end
+
+        def only_for polymorphic_type_values, &bloc
+          @currently_only_for = polymorphic_type_values
+          yield if block_given?
+          remove_instance_variable(:@currently_only_for)
+        end
+
+        def polymorphic?
+          self.fields.key? :polymorphic_type
+        end
+
+        def field_applicable? f, p_type=nil
+          applicable? :fields, f, p_type
+        end
+
+        def relationship_applicable? f, p_type=nil
+          applicable? :relationships, f, p_type
+        end
+
+        def applicable? target, f, p_type=nil
+          return false unless self.__send__(target).key?(f)
+          return true unless self.polymorphic?
+          return true unless self.__send__(target)[f].key?(:only_for)
+          return true if p_type.nil?
+          self.__send__(target)[f][:only_for].include? p_type
+        end
+        private :applicable?
+
         def label sym # sets the label_field
           @label_field = sym.to_sym
         end
-
+        
         def label_field
-          @label_field || self.fields.keys[1]
+          return @label_field if self.fields.empty?
+          @label_field || self.fields.find do |k,v| 
+            not [:id,:polymorphic_type].include?(v[:type])
+          end[0]
         end
 
         def sort_by f, direction=:asc
@@ -88,6 +144,7 @@ module PopulateMe
           WebUtils.ensure_key! o, :foreign_key, "#{WebUtils.dasherize_class_name(self.name).gsub('-','_')}_id"
           o[:foreign_key] = o[:foreign_key].to_sym
           WebUtils.ensure_key! o, :dependent, true
+          complete_only_for_field_option o
           self.relationships[name] = o
 
           define_method(name) do
@@ -116,6 +173,18 @@ module PopulateMe
 
       end
 
+      # Instance methods
+
+      def field_applicable? f
+        p_type = self.class.polymorphic? ? self.polymorphic_type : nil
+        self.class.field_applicable? f, p_type
+      end
+
+      def relationship_applicable? f
+        p_type = self.class.polymorphic? ? self.polymorphic_type : nil
+        self.class.relationship_applicable? f, p_type
+      end
+
     end
   end
 end

data/lib/populate_me/version.rb

@@ -1,4 +1,4 @@
 module PopulateMe
-  VERSION = '0.7.1'
+  VERSION = '0.8.0'
 end
 

data/test/test_document.rb

@@ -24,10 +24,9 @@ describe PopulateMe::Document do
   end
 
   describe '#to_s' do
-    it 'Delegates to #inspect' do
-      subject.stub :inspect, "inspection" do
-        assert_equal "inspection", subject.to_s
-      end
+    it 'Defaults to class name and ID' do
+      obj = subject_class.new id: '42'
+      assert_equal "#{subject_class} 42", obj.to_s
     end
     describe "Has a label field" do
       describe "And the field is not blank" do
@@ -38,17 +37,26 @@ describe PopulateMe::Document do
             end
           end
         end
+        it 'Does not pass a reference that can be modified' do
+          subject_class.stub :label_field, :my_label_field do
+            subject.stub :my_label_field, 'my label' do
+              assert_equal 'my label', subject.to_s
+              var = subject.to_s
+              var << 'BOOM'
+              assert_equal 'my label', subject.to_s
+            end
+          end
+        end
       end
       describe "And the field is blank" do
-        it "Delegates to the #inspect" do
+        it 'Defaults to class name and ID' do
           subject_class.stub :label_field, :my_label_field do
-            subject.stub :inspect, "inspection" do
-              subject.stub :my_label_field, '' do
-                assert_equal 'inspection', subject.to_s
-              end
-              subject.stub :my_label_field, nil do
-                assert_equal 'inspection', subject.to_s
-              end
+            obj = subject_class.new id: '42'
+            subject.stub :my_label_field, '' do
+              assert_equal "#{subject_class} 42", obj.to_s
+            end
+            subject.stub :my_label_field, nil do
+              assert_equal "#{subject_class} 42", obj.to_s
             end
           end
         end

data/test/test_document_admin_adapter.rb

@@ -41,10 +41,29 @@ describe PopulateMe::Document, 'AdminAdapter' do
     end
   end
 
+  describe '::to_admin_list' do
+    class PolyAdapted < PopulateMe::Document
+      polymorphic values: ['Shape 1', 'Shape 2']
+    end
+    class NotPolyAdapted < PopulateMe::Document
+    end
+    it 'Contains polymorphic_type values and predicate if polymorphic' do
+      assert PolyAdapted.to_admin_list[:is_polymorphic]
+      assert_equal ['Shape 1', 'Shape 2'], PolyAdapted.to_admin_list[:polymorphic_type_values]
+      refute NotPolyAdapted.to_admin_list[:is_polymorphic]
+      assert_nil NotPolyAdapted.to_admin_list[:polymorphic_type_values]
+    end
+  end
+
   describe '#to_admin_list_item' do
     class ContentTitle < PopulateMe::Document
       field :content
     end
+    class PolyListItem < PopulateMe::Document
+      field :name
+      relationship :images, only_for: 'Slider'
+      relationship :paragraphs, only_for: 'Chapter'
+    end
     it 'Sets ID as a string version' do
       doc = ContentTitle.new id: 3
       assert_equal '3', doc.to_admin_list_item[:id]
@@ -67,6 +86,14 @@ describe PopulateMe::Document, 'AdminAdapter' do
         assert_equal doc.content, title
       end
     end
+    describe 'Polymorphism' do
+      it 'Only keeps in the local menu applicable relationships' do
+        doc = PolyListItem.new(polymorphic_type: 'Slider')
+        list_item = doc.to_admin_list_item request: Struct.new(:script_name).new('/admin')
+        assert_equal 1, list_item[:local_menu].size
+        assert_equal 'Images', list_item[:local_menu][0][:title]
+      end
+    end
   end
 
   describe '::admin_find ::admin_find_first' do
@@ -148,4 +175,47 @@ describe PopulateMe::Document, 'AdminAdapter' do
 
   end
 
+  describe '#to_admin_form' do
+    class PolyForm < PopulateMe::Document
+      field :name
+      field :image, only_for: 'Image'
+      field :title, only_for: 'Article'
+      field :content, only_for: 'Article'
+      field :position
+    end
+    class NotPolyForm < PopulateMe::Document
+      field :name
+    end
+    it 'Sets page_title according to label_field or class name when new' do
+      obj = NotPolyForm.new
+      form = obj.to_admin_form
+      assert_equal 'New Not Poly Form', form[:page_title]
+      obj = NotPolyForm.new name: "No Poly"
+      obj._is_new = false
+      form = obj.to_admin_form
+      assert_equal 'No Poly', form[:page_title]
+    end
+    it 'Only has fields for the current polymorphic type' do
+      obj = PolyForm.new polymorphic_type: 'Article'
+      form = obj.to_admin_form
+      assert_nil form[:fields].find{|f| f[:field_name]==:image}
+      refute_nil form[:fields].find{|f| f[:field_name]==:title}
+      refute_nil form[:fields].find{|f| f[:field_name]==:content}
+    end
+    it 'Works when not polymorphic' do
+      obj = NotPolyForm.new
+      form = obj.to_admin_form
+      refute_nil form[:fields].find{|f| f[:field_name]==:name}
+    end
+    it 'Includes the polymorphic_type at top level' do
+      obj = PolyForm.new polymorphic_type: 'Article'
+      form = obj.to_admin_form
+      assert_equal 'Article', form[:polymorphic_type]
+      obj = PolyForm.new
+      form = obj.to_admin_form
+      assert_nil form[:polymorphic_type]
+    end
+  end
+
 end
+

data/test/test_document_schema.rb

@@ -119,5 +119,144 @@ describe PopulateMe::Document, 'Schema' do
 
   end
 
+  describe 'Polymorphism' do
+
+    class PolyBox < PopulateMe::Document
+      field :first_name
+      field :last_name
+      field :middle_name, only_for: ['Middle', 'Long name']
+      field :nick_name, only_for: 'Funny'
+      field :third_name, only_for: 'Long name'
+    end
+
+    class NotPoly < PopulateMe::Document
+      field :name
+      relationship :images
+    end
+
+    class JustPoly < PopulateMe::Document
+      polymorphic
+    end
+
+    class PolyCustom < PopulateMe::Document
+      polymorphic type: :text, custom_option: 'Custom'
+    end
+
+    class PolyApplicable < PopulateMe::Document
+      field :name_1, only_for: 'Shape 1'
+      field :name_2, only_for: 'Shape 2'
+      field :position
+    end
+
+    class PolyLabel < PopulateMe::Document
+      polymorphic
+      field :name
+    end
+
+    class PolyRelationship < PopulateMe::Document
+      field :name
+      field :short_description, only_for: 'Chapter'
+      relationship :images, only_for: 'Slider'
+      relationship :paragraphs, only_for: 'Chapter'
+    end
+
+    class PolyGroup < PopulateMe::Document
+      only_for 'Slider' do
+        field :name
+        relationship :images
+      end
+      field :no_only_for
+      only_for ['Try','This'] do
+        field :crazy
+      end
+      field :position
+    end
+
+    it 'Creates a field for polymorphic type if it does not exist yet' do
+      assert_equal :polymorphic_type, PolyBox.fields[:polymorphic_type][:type]
+      assert_equal :polymorphic_type, JustPoly.fields[:polymorphic_type][:type]
+      assert_equal :polymorphic_type, PolyRelationship.fields[:polymorphic_type][:type]
+    end
+
+    it 'By default polymorphic_type is hidden and not wrapped' do
+      assert_equal :hidden, PolyBox.fields[:polymorphic_type][:input_attributes][:type]
+      refute PolyBox.fields[:polymorphic_type][:wrap]
+    end
+
+    it 'Does not create polymorphic type field if not required' do
+      assert_nil NotPoly.fields[:polymorphic_type]
+    end
+
+    it 'Gathers all polymorphic type unique values' do
+      assert_equal ['Middle', 'Long name', 'Funny'], PolyBox.fields[:polymorphic_type][:values]
+      assert_equal [], JustPoly.fields[:polymorphic_type][:values]
+      assert_equal ['Chapter', 'Slider'], PolyRelationship.fields[:polymorphic_type][:values]
+    end
+
+    it 'Adds or update field options for polymorphic type passed as arguments' do
+      assert_equal :text, PolyCustom.fields[:polymorphic_type][:type]
+      assert_equal 'Custom', PolyCustom.fields[:polymorphic_type][:custom_option]
+    end
+
+    it 'Forces only_for field option to be an Array if String' do
+      assert_nil PolyBox.fields[:first_name][:only_for]
+      assert_equal ['Middle', 'Long name'], PolyBox.fields[:middle_name][:only_for]
+      assert_equal ['Funny'], PolyBox.fields[:nick_name][:only_for]
+      assert_equal ['Slider'], PolyRelationship.relationships[:images][:only_for]
+    end
+
+    it 'Has a polymorphic? predicate' do
+      assert PolyBox.polymorphic?
+      refute NotPoly.polymorphic?
+    end
+
+    it 'Knows when a field is applicable to a polymorphic_type' do
+      assert NotPoly.field_applicable?(:name, nil) # Not polymorphic
+      assert NotPoly.field_applicable?(:name, 'Fake') # Not polymorphic
+      refute NotPoly.field_applicable?(:non_existing_field, nil) # Not polymorphic
+      assert PolyApplicable.field_applicable?(:polymorphic_type, 'Shape 1') # no only_for
+      assert PolyApplicable.field_applicable?(:position, 'Shape 1') # no only_for
+      refute PolyApplicable.field_applicable?(:name_2, 'Shape 1') # not included
+      assert PolyApplicable.field_applicable?(:name_2, nil) # no type set yet
+
+      assert NotPoly.new.field_applicable?(:name) # Not polymorphic
+      refute NotPoly.new.field_applicable?(:non_existing_field) # Not polymorphic
+      assert PolyApplicable.new(polymorphic_type: 'Shape 2').field_applicable?(:name_2)
+      refute PolyApplicable.new(polymorphic_type: 'Shape 2').field_applicable?(:name_1)
+      assert PolyApplicable.new.field_applicable?(:name_2) # No type set yet
+      assert PolyApplicable.new.field_applicable?(:name_1) # No type set yes
+    end
+
+    it 'Knows when a relationship is applicable to a polymorphic_type' do
+      assert PolyRelationship.relationship_applicable?(:images, 'Slider')
+      refute PolyRelationship.relationship_applicable?(:images, 'Chapter')
+      assert PolyRelationship.new(polymorphic_type: 'Slider').relationship_applicable?(:images)
+      refute PolyRelationship.new(polymorphic_type: 'Chapter').relationship_applicable?(:images)
+    end
+
+    it 'Ignores polymorphic_type when picking the default label_field' do
+      assert_equal :name, PolyLabel.label_field
+    end
+
+    it 'Uses groups to define only_for option for all included fields and relationships' do
+      assert_equal :polymorphic_type, PolyGroup.fields[:polymorphic_type][:type]
+      assert_equal ['Slider', 'Try', 'This'], PolyGroup.fields[:polymorphic_type][:values]
+      assert_equal ['Slider'], PolyGroup.fields[:name][:only_for]
+      assert_equal ['Slider'], PolyGroup.relationships[:images][:only_for]
+      assert_equal ['Try','This'], PolyGroup.fields[:crazy][:only_for]
+    end
+
+    it 'Group only_for option does not leak on special fields' do
+      refute PolyGroup.fields[:id].key?(:only_for)
+      refute PolyGroup.fields[:polymorphic_type].key?(:only_for)
+    end
+
+    it 'Group only_for option does not leak outside of their scope' do
+      refute PolyGroup.fields[:no_only_for].key?(:only_for)
+      refute PolyGroup.fields[:position].key?(:only_for)
+    end
+
+  end
+
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: populate-me
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Mickael Riga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-10 00:00:00.000000000 Z
+date: 2018-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: web-utils