populate-me 0.0.33 → 0.1.0

data/lib/populate_me/document.rb

@@ -0,0 +1,178 @@
+require 'web_utils'
+require 'ostruct'
+
+require 'populate_me/document_mixins/typecasting'
+require 'populate_me/document_mixins/outcasting'
+require 'populate_me/document_mixins/schema'
+require 'populate_me/document_mixins/admin_adapter'
+require 'populate_me/document_mixins/callbacks'
+require 'populate_me/document_mixins/validation'
+require 'populate_me/document_mixins/persistence'
+
+module PopulateMe
+
+  class MissingDocumentError < StandardError; end
+  class MissingAttachmentClassError < StandardError; end
+
+  class Document
+
+    # PopulateMe::Document is the base for any document
+    # the Backend is supposed to deal with.
+    #
+    # Any module for a specific ORM or ODM should
+    # subclass it.
+    # It contains what is not specific to a particular kind
+    # of database and it provides defaults.
+    #
+    # It can be used on its own but it keeps everything
+    # in memory. Which means it is only for tests and conceptual
+    # understanding.
+    
+    include DocumentMixins::Typecasting
+    include DocumentMixins::Outcasting
+    include DocumentMixins::Schema
+    include DocumentMixins::AdminAdapter
+    include DocumentMixins::Callbacks
+    include DocumentMixins::Validation
+    include DocumentMixins::Persistence
+
+    class << self
+
+      def inherited sub 
+        super
+        sub.callbacks = WebUtils.deep_copy callbacks
+        sub.settings = settings.dup # no deep copy because of Mongo.settings.db
+      end
+
+      def to_s
+        super.gsub(/[A-Z]/, ' \&')[1..-1].gsub('::','')
+      end
+
+      def to_s_short
+        self.name[/[^:]+$/].gsub(/[A-Z]/, ' \&')[1..-1]
+      end
+
+      def to_s_plural; WebUtils.pluralize(self.to_s); end
+      def to_s_short_plural; WebUtils.pluralize(self.to_s_short); end
+
+      def from_hash hash, o={}
+        self.new(_is_new: false).set_from_hash(hash, o).snapshot
+      end
+
+      def cast o={}, &block
+        target = block.arity==0 ? instance_eval(&block) : block.call(self)
+        return nil if target.nil?
+        return from_hash(target, o) if target.is_a?(Hash)
+        return target.map{|t| from_hash(t,o)} if target.respond_to?(:map)
+        raise(TypeError, "The block passed to #{self.name}::cast is meant to return a Hash or a list of Hash which respond to `map`")
+      end
+
+      # inheritable settings
+      attr_accessor :settings
+      def set name, value
+        self.settings[name] = value
+      end
+
+    end
+
+    attr_accessor :id, :_is_new, :_old
+
+    def initialize attributes=nil 
+      self._is_new = true
+      set attributes if attributes
+      self._errors = {}
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{to_h.inspect}>"
+    end
+
+    def to_s
+      return inspect if self.class.label_field.nil?
+      me = self.__send__(self.class.label_field)
+      WebUtils.blank?(me) ? inspect : me
+    end
+
+    def new?; self._is_new; end
+
+    def to_h
+      persistent_instance_variables.inject({'_class'=>self.class.name}) do |h,var|
+        k = var.to_s[1..-1]
+        v = instance_variable_get var
+        if v.is_a? Array
+          h[k] = v.map(&:to_h)
+        else
+          h[k] = v
+        end
+        h
+      end
+    end
+    alias_method :to_hash, :to_h
+
+    def snapshot
+      self._old = self.to_h
+      self
+    end
+
+    def nested_docs
+      persistent_instance_variables.map do |var|
+        instance_variable_get var
+      end.find_all do |val|
+        val.is_a? Array
+      end.flatten
+    end
+
+    def == other
+      return false unless other.respond_to?(:to_h)
+      other.to_h==to_h
+    end
+
+    def set attributes
+      attributes.dup.each do |k,v| 
+        setter = "#{k}="
+        if respond_to? setter
+          __send__ setter, v
+        end
+      end
+      self
+    end
+
+    def set_defaults o={}
+      self.class.fields.each do |k,v|
+        if v.key?(:default)&&(__send__(k).nil?||o[:force])
+          set k.to_sym => WebUtils.get_value(v[:default],self)
+        end
+      end
+      self
+    end
+
+    def set_from_hash hash, o={}
+      raise(TypeError, "#{hash} is not a Hash") unless hash.is_a? Hash
+      hash = hash.dup # Leave original untouched
+      hash.delete('_class')
+      hash.each do |k,v|
+        getter = k.to_sym
+        if v.is_a? Array
+          break unless respond_to?(getter)
+          __send__(getter).clear
+          v.each do |d|
+            obj =  WebUtils.resolve_class_name(d['_class']).new.set_from_hash(d,o)
+            __send__(getter) << obj
+          end
+        else
+          v = typecast(getter,v) if o[:typecast]
+          set getter => v
+        end
+      end
+      self
+    end
+
+    # class settings
+    def settings
+      self.class.settings
+    end
+    self.settings = OpenStruct.new
+
+  end
+end
+

data/lib/populate_me/document_mixins/admin_adapter.rb

@@ -0,0 +1,131 @@
+module PopulateMe
+  module DocumentMixins
+    module AdminAdapter
+
+      def to_admin_url
+        "#{Utils.dasherize_class_name(self.class.name)}/#{id}".sub(/\/$/,'')
+      end
+
+      def admin_image_url
+        thefield = self.class.admin_image_field
+        return nil if thefield.nil?
+        self.attachment(thefield).url(:populate_me_thumb)
+      end
+
+      def to_admin_list_item o={}
+        {
+          class_name: self.class.name,
+          id: self.id,
+          admin_url: to_admin_url,
+          title: to_s,
+          image_url: admin_image_url,
+          local_menu: self.class.relationships.inject([]) do |out,(k,v)|
+            unless v[:hidden]
+              out << {
+                title: "#{v[:label]}",
+                href: "#{o[:request].script_name}/list/#{Utils.dasherize_class_name(v[:class_name])}?filter[#{v[:foreign_key]}]=#{self.id}"
+              }
+              out
+            end
+          end
+        }
+      end
+
+      def to_admin_form o={}
+        o[:input_name_prefix] ||= 'data'
+        class_item = {
+          type: :hidden,
+          input_name: "#{o[:input_name_prefix]}[_class]",
+          input_value: self.class.name,
+        }
+        self.class.complete_field_options :_class, class_item
+        items = self.class.fields.inject([class_item]) do |out,(k,item)|
+          item = item.dup
+          if item[:form_field]
+            outcast k, item, o
+            out << item
+          end
+          out
+        end
+        {
+          template: "template#{'_nested' if o[:nested]}_form",
+          page_title: self.new? ? "New #{self.class.to_s_short}" : self.to_s,
+          admin_url: self.to_admin_url,
+          is_new: self.new?,
+          fields: items
+        }
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def admin_image_field
+          res = self.fields.find do |k,v|
+            if v[:type]==:attachment and !v[:variations].nil?
+              v[:variations].any?{|var|var.name==:populate_me_thumb}
+            else
+              false
+            end
+          end
+          res.nil? ? nil : res[0]
+        end
+
+        def admin_get id
+          self.cast do
+            documents.find{|doc| doc[id_string_key]==id }
+          end
+        end
+
+        def admin_find o={}
+          o[:query] ||= {}
+          docs = self.cast{documents}.find_all do |d|
+            o[:query].inject(true) do |out,(k,v)|
+              out && (d.__send__(k)==v)
+            end
+          end
+          docs.sort!(&@sort_proc) if @sort_proc.is_a?(Proc)
+          docs
+        end
+
+        def sort_field_for o={}
+          filter = o[:params][:filter]
+          return nil if !filter.nil?&&filter.size>1
+          expected_scope = filter.nil? ? nil : filter.keys[0].to_sym
+          f = self.fields.find do |k,v| 
+            v[:type]==:position&&v[:scope]==expected_scope
+          end
+          f.nil? ? nil : f[0]
+        end
+
+        def to_admin_list o={}
+          o[:params] ||= {}
+          unless o[:params][:filter].nil?
+            query = o[:params][:filter].inject({}) do |q, (k,v)|
+              q[k.to_sym] = self.new.typecast(k,v)
+              q
+            end
+            new_data = Rack::Utils.build_nested_query(data: o[:params][:filter])
+          end
+          {
+            template: 'template_list',
+            page_title: self.to_s_short_plural,
+            dasherized_class_name: PopulateMe::Utils.dasherize_class_name(self.name),
+            new_data: new_data,
+            sort_field: self.sort_field_for(o),
+            # 'command_plus'=> !self.populate_config[:no_plus],
+            # 'command_search'=> !self.populate_config[:no_search],
+            items: self.admin_find(query: query).map do |d| 
+              d.to_admin_list_item(o) 
+            end
+          }
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/populate_me/document_mixins/callbacks.rb

@@ -0,0 +1,104 @@
+module PopulateMe
+  module DocumentMixins
+    module Callbacks
+
+      def exec_callback name
+        name = name.to_sym
+        return self if self.class.callbacks[name].nil?
+        self.class.callbacks[name].each do |job|
+          if job.respond_to?(:call)
+            self.instance_exec name, &job
+          else
+            meth = self.method(job)
+            meth.arity==1 ? meth.call(name) : meth.call
+          end
+        end
+        self
+      end
+
+      def recurse_callback name
+        nested_docs.each do |d|
+          d.exec_callback name
+        end
+      end
+
+      def ensure_id
+        if self.id.nil?
+          self.id = WebUtils::generate_random_id
+        end
+        self
+      end
+
+      def ensure_not_new; self._is_new = false; end
+
+      def ensure_delete_related
+        self.class.relationships.each do |k,v|
+          if v[:dependent]
+            klass = WebUtils.resolve_class_name v[:class_name]
+            next if klass.nil?
+            klass.admin_find(query: {v[:foreign_key]=>self.id}).each do |d|
+              d.delete
+            end
+          end
+        end
+      end
+
+      def ensure_delete_attachments
+        self.class.fields.each do |k,v|
+          if v[:type]==:attachment
+            self.attachment(k).delete_all
+          end
+        end
+      end
+
+      def ensure_new; self._is_new = true; end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          [:save,:create,:update,:delete].each do |cb|
+            before cb, :recurse_callback
+            after cb, :recurse_callback
+          end
+          before :create, :ensure_id
+          after :create, :ensure_not_new
+          after :save, :snapshot
+          before :delete, :ensure_delete_related
+          before :delete, :ensure_delete_attachments
+          after :delete, :ensure_new
+        end
+      end
+
+      module ClassMethods
+
+        attr_accessor :callbacks
+
+        def register_callback name, item=nil, options={}, &block
+          name = name.to_sym
+          if block_given?
+            options = item || {}
+            item = block
+          end
+          self.callbacks ||= {}
+          self.callbacks[name] ||= []
+          if options[:prepend]
+            self.callbacks[name].unshift item
+          else
+            self.callbacks[name] << item
+          end
+        end
+
+        def before name, item=nil, options={}, &block
+          register_callback "before_#{name}", item, options, &block
+        end
+
+        def after name, item=nil, options={}, &block
+          register_callback "after_#{name}", item, options, &block
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/populate_me/document_mixins/outcasting.rb

@@ -0,0 +1,49 @@
+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[: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
+        __send__(meth, field, item, o) if respond_to?(meth)
+      end
+
+      def outcast_list field, item, o={}
+        item[:items] = self.__send__(field).map do |nested|
+         nested.to_admin_form(o.merge(input_name_prefix: item[:input_name]+'[]'))
+        end
+      end
+
+      def outcast_select field, item, o={}
+        unless item[:select_options].nil?
+          opts = WebUtils.get_value(item[:select_options],self).dup
+          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
+            opt[:selected] = true if item[:input_value]==opt[:value]
+            opt
+          end
+          item[:select_options] = opts
+        end
+      end
+
+      def outcast_attachment field, item, o={}
+        item[:url] = self.attachment(field).url
+      end
+
+    end
+  end
+end
+