populate-me 0.12.0

data/lib/populate_me/document_mixins/outcasting.rb

@@ -0,0 +1,83 @@
+module PopulateMe
+  module DocumentMixins
+    module Outcasting
+
+      # This module prepares the field for being send to the Admin API
+      # and build the form.
+      # It compiles the value and all other info in a hash.
+      # Therefore, it is a complement to the AdminAdapter module.
+
+      def outcast field, item, o={}
+        item = item.dup
+        item[:input_name] = "#{o[:input_name_prefix]}[#{item[:field_name]}]"
+        unless item[:type]==:list
+          WebUtils.ensure_key! item, :input_value, self.__send__(field)
+        end
+        meth = "outcast_#{item[:type]}".to_sym
+        if respond_to?(meth)
+          __send__(meth, field, item, o) 
+        else
+          item
+        end
+      end
+
+      def outcast_list field, item, o={}
+        item = item.dup
+        item[:items] = self.__send__(field).map do |nested|
+         nested.to_admin_form(o.merge(input_name_prefix: item[:input_name]+'[]'))
+        end
+        item
+      end
+
+      def outcast_select field, item, o={}
+        item = item.dup
+        unless item[:select_options].nil?
+          if item[:multiple]==true
+            item[:input_name] = item[:input_name]+'[]'
+          end
+          opts = WebUtils.deep_copy(WebUtils.get_value(item[:select_options],self))
+          opts.map! do |opt|
+            if opt.is_a?(String)||opt.is_a?(Symbol)
+              opt = [opt.to_s.capitalize,opt]
+            end
+            if opt.is_a?(Array)
+              opt = {description: opt[0].to_s, value: opt[1].to_s}
+            end
+            if item[:input_value].respond_to?(:include?)
+              opt[:selected] = true if item[:input_value].include?(opt[:value])
+            else
+              opt[:selected] = true if item[:input_value]==opt[:value]
+            end
+            opt
+          end
+          if item[:multiple]
+            (item[:input_value]||[]).reverse.each do |iv|
+              opt = opts.find{|opt| opt[:value]==iv }
+              opts.unshift(opts.delete(opt)) unless opt.nil?
+            end
+          end
+          item[:select_options] = opts
+          item
+        else
+          item
+        end
+      end
+
+      def outcast_attachment field, item, o={}
+        item = item.dup
+        item[:url] = self.attachment(field).url
+        item
+      end
+
+      def outcast_price field, item, o={}
+        item = item.dup
+        if item[:input_value].is_a?(Integer)
+          item[:input_value] = WebUtils.display_price item[:input_value]
+        end
+        item
+      end
+
+    end
+  end
+end
+

data/lib/populate_me/document_mixins/persistence.rb

@@ -0,0 +1,95 @@
+module PopulateMe
+  module DocumentMixins
+    module Persistence
+
+      def persistent_instance_variables
+        instance_variables.select do |k|
+          if self.class.fields.empty?
+            k !~ /^@_/
+          else
+            self.class.fields.key? k[1..-1].to_sym
+          end
+        end
+      end
+
+      def attachment f
+        attacher = WebUtils.resolve_class_name self.class.fields[f][:class_name]
+        attacher.new self, f
+      end
+
+      # Saving
+      def save
+        return unless valid?
+        exec_callback :before_save
+        if new?
+          exec_callback :before_create
+          id = perform_create
+          exec_callback :after_create
+        else
+          exec_callback :before_update
+          id = perform_update
+          exec_callback :after_update
+        end
+        exec_callback :after_save
+        id
+      end
+      def perform_create
+        self.class.documents << self.to_h
+        self.id
+      end
+      def perform_update
+        index = self.class.documents.index{|d| d['id']==self.id }
+        raise MissingDocumentError, "No document can be found with this ID: #{self.id}" if self.id.nil?||index.nil?
+        self.class.documents[index] = self.to_h
+      end
+
+      # Deletion
+      def delete o={}
+        exec_callback :before_delete
+        perform_delete
+        exec_callback :after_delete
+      end
+      def perform_delete
+        index = self.class.documents.index{|d| d['id']==self.id }
+        raise MissingDocumentError, "No document can be found with this ID: #{self.id}" if self.id.nil?||index.nil?
+        self.class.documents.delete_at(index)
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        attr_writer :documents
+
+        def documents; @documents ||= []; end
+
+        def id_string_key
+          (self.fields.keys[0]||'id').to_s
+        end
+
+        def set_indexes f, ids=[]
+          if self.fields and self.fields[f.to_sym] and self.fields[f.to_sym][:direction]==:desc
+            ids = ids.dup.reverse
+          end
+          ids.each_with_index do |id,i|
+            self.documents.each do |d|
+              d[f.to_s] = i if d[self.id_string_key]==id
+            end
+          end
+          self
+        end
+
+        def is_unique unique_id='unique'
+          if self.admin_get(unique_id).nil?
+            self.new.set_from_hash({id:unique_id}).save
+          end
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/populate_me/document_mixins/schema.rb

@@ -0,0 +1,198 @@
+module PopulateMe
+  module DocumentMixins
+    module Schema
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        attr_writer :fields
+        attr_accessor :label_field
+
+        def fields; @fields ||= {}; end
+
+        def field name, o={}
+          set_id_field if self.fields.empty? and o[:type]!=:id
+          complete_field_options name, o
+          if o[:type]==:list
+            define_method(name) do
+              var = "@#{name}"
+              instance_variable_set(var, instance_variable_get(var)||[])
+            end
+          else
+            attr_accessor name
+          end
+          self.fields[name] = o
+        end
+
+        def complete_field_options name, o={}
+          o[:field_name] = name
+          WebUtils.ensure_key! o, :type, :string
+          WebUtils.ensure_key! o, :form_field, ![:id,:position].include?(o[:type])
+          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?
+            o[:class_name] = o[:class_name].name unless o[:class_name].is_a?(String)
+          end
+          if o[:type]==:list
+            o[:class_name] = WebUtils.guess_related_class_name(self.name,o[:class_name]||name)
+            o[:dasherized_class_name] = WebUtils.dasherize_class_name o[:class_name]
+          else
+            WebUtils.ensure_key! o, :input_attributes, {}
+            o[:input_attributes][:type] = :hidden if o[:type]==:hidden
+            unless o[:type]==:text
+              WebUtils.ensure_key! o[:input_attributes], :type, :text
+            end
+          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
+
+        def position_field o={}
+          name = o[:name]||:position
+          o[:type] = :position
+          field name, o
+          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
+          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
+          raise(ArgumentError) unless [:asc,:desc].include? direction
+          raise(ArgumentError) unless self.new.respond_to? f
+          @sort_proc = Proc.new do |a,b|
+            a,b = b,a if direction==:desc 
+            a.__send__(f)<=>b.__send__(f) 
+          end
+          self
+        end
+
+        def relationships; @relationships ||= {}; end
+
+        def relationship name, o={}
+          o[:class_name] = WebUtils.guess_related_class_name(self.name,o[:class_name]||name)
+          WebUtils.ensure_key! o, :label, name.to_s.gsub('_',' ').capitalize
+          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
+            var = "@cached_#{name}"
+            instance_variable_set(var, instance_variable_get(var)||WebUtils.resolve_class_name(o[:class_name]).admin_find(query: {o[:foreign_key]=>self.id}))
+          end
+
+          define_method("#{name}_first".to_sym) do
+            var = "@cached_#{name}_first"
+            instance_variable_set(var, instance_variable_get(var)||WebUtils.resolve_class_name(o[:class_name]).admin_find_first(query: {o[:foreign_key]=>self.id}))
+          end
+        end
+
+        def to_select_options o={}
+          proc do
+            items = self.admin_find({
+              query: (o[:query]||{}), 
+              fields: [self.id_string_key, self.label_field, self.admin_image_field].compact.uniq
+            })
+            output = items.sort_by do |i|
+              i.to_s.downcase
+            end.map do |i|
+              item = { description: i.to_s, value: i.id }
+              unless self.admin_image_field.nil?
+                item.merge! preview_uri: i.admin_image_url
+              end
+              item
+            end
+            output.unshift(description: '?', value: '') if o[:allow_empty]
+            output
+          end
+        end
+
+      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/document_mixins/typecasting.rb

@@ -0,0 +1,70 @@
+module PopulateMe
+  module DocumentMixins
+    module Typecasting
+
+      # This module deals with typecasting the fields
+      # when they are received as strings,
+      # generally from a form or a csv file
+
+      def typecast k, v
+        unless self.class.fields.key?(k)
+          return WebUtils.automatic_typecast(v) 
+        end
+        f = self.class.fields[k].dup
+        meth = "typecast_#{f[:type]}".to_sym
+        unless respond_to? meth
+          return WebUtils.automatic_typecast(v, [f[:type],:nil])
+        end
+        __send__ meth, k, v
+      end
+
+      def typecast_integer k, v
+        v.to_i
+      end
+
+      def typecast_price k, v
+        return nil if WebUtils.blank?(v)
+        WebUtils.parse_price(v)
+      end
+
+      def typecast_select k, v
+        if v.is_a?(Array)
+          v.reject{|str| str=='nil' }
+        else
+          v
+        end
+      end
+
+      def typecast_date k, v
+        if v[/\d\d(\/|-)\d\d(\/|-)\d\d\d\d/]
+          Date.parse v
+        elsif v[/\d\d\d\d(\/|-)\d\d(\/|-)\d\d/]
+          Date.parse v
+        else
+          nil
+        end
+      end
+
+      def typecast_datetime k, v
+        if v[/\d\d(\/|-)\d\d(\/|-)\d\d\d\d \d\d?:\d\d?:\d\d?/]
+          d,m,y,h,min,s = v.split(/[-:\s\/]/)
+          Time.utc(y,m,d,h,min,s)
+        else
+          nil
+        end
+      end
+
+      def typecast_attachment k, v
+        attached = self.attachment k
+        if WebUtils.blank? v
+          attached.delete_all
+          return nil
+        elsif v.is_a?(Hash)&&v.key?(:tempfile)
+          return attached.create v
+        end
+      end
+
+    end
+  end
+end
+

data/lib/populate_me/document_mixins/validation.rb

@@ -0,0 +1,44 @@
+module PopulateMe
+  module DocumentMixins
+    module Validation
+
+      attr_accessor :_errors
+      
+      def errors; self._errors; end
+
+      def error_on k,v 
+        self._errors[k] = (self._errors[k]||[]) << v
+        self
+      end
+
+      def valid?
+        self._errors = {}
+        exec_callback :before_validate
+        validate
+        exec_callback :after_validate
+        nested_docs.reduce self._errors.empty? do |result,d|
+          result &= d.valid?
+        end
+      end
+
+      def validate; end
+
+      def error_report
+        report = self._errors.dup || {}
+        persistent_instance_variables.each do |var|
+          value = instance_variable_get var
+          if is_nested_docs?(value)
+            k = var[1..-1].to_sym
+            report[k] = []
+            value.each do |d|
+              report[k] << d.error_report
+            end
+          end
+        end
+        report
+      end
+
+    end
+  end
+end
+