populate-me 0.0.0

data/lib/populate_me/mongo/mutation.rb

@@ -0,0 +1,266 @@
+module PopulateMe
+  module Mongo
+    module Mutation
+  
+      # Most important MongoDB module
+      # It defines the ODM
+  
+    	def self.included(weak)
+    		weak.extend(MutateClass)
+    		weak.db = DB
+    		weak.schema = BSON::OrderedHash.new
+    		weak.relationships = BSON::OrderedHash.new
+    	end
+
+      module MutateClass
+    	  attr_accessor :db, :schema, :relationships
+    		attr_writer :label_column, :sorting_order
+
+        LABEL_COLUMNS = ['title', 'label', 'fullname', 'full_name', 'surname', 'lastname', 'last_name', 'name', 'firstname', 'first_name', 'login', 'caption', 'reference', 'file_name', 'body', '_id']
+    		def label_column; @label_column ||= LABEL_COLUMNS.find{|c| @schema.keys.include?(c)||c=='_id'}; end
+    	  def foreign_key_name(plural=false); "id#{'s' if plural}_"+self.name; end
+    		def human_name; self.name.gsub(/([A-Z])/, ' \1')[1..-1]; end
+    		def human_plural_name; human_name+'s'; end
+    		def collection; db[self.name]; end
+    		def ref(id)
+    		  if id.is_a?(String)&&BSON::ObjectId.legal?(id)
+    			  id = BSON::ObjectId.from_string(id)
+    			elsif !id.is_a?(BSON::ObjectId)
+    			  id = ''
+    			end
+    			{'_id'=>id}
+    		end
+    		def find(selector={},opts={})
+          opts = {:sort=>self.sorting_order}.update(opts)
+          collection.find(selector,opts).extend(CursorMutation)
+        end
+        def find_one(spec_or_object_id=nil,opts={})
+          opts = {:sort=>self.sorting_order}.update(opts)
+          item = collection.find_one(spec_or_object_id,opts)
+          item.nil? ? nil : self.new(item)
+        end
+        def count(opts={}); collection.count(opts); end
+
+        def sorting_order
+    			@sorting_order ||= if @schema.key?('position')&&!@schema['position'][:scope].nil?
+    				[[@schema['position'][:scope], :asc], ['position', :asc]]
+    			elsif @schema.key?('position')
+    				[['position', :asc],['_id', :asc]]
+    			else
+    				['_id', :asc]
+    			end
+    		end
+
+    		def sort(id_list)
+    		  id_list.each_with_index do |id, position|
+    			  collection.update(ref(id), {'$set' => {'position'=>position}})
+    			end
+    		end
+
+    		# CRUD
+    		def get(id, opts={}); doc = collection.find_one(ref(id), opts); doc.nil? ? nil : self.new(doc); end
+    		def delete(id); collection.remove(ref(id)); end
+
+    		def is_unique(doc={})
+    		  return unless collection.count==0
+    		  doc = {'_id'=>BSON::ObjectId('000000000000000000000000')}.update(doc)
+    		  d = self.new
+    			d.doc.update(doc)
+    			d.save 
+    		end
+
+    		private
+    		def slot(name,opts={}); @schema[name] = {:type=>:string}.update(opts); end
+    		def image_slot(name='image',opts={})
+    		  slot name, {:type=>:attachment}.update(opts)
+    			slot "#{name}_tooltip"
+    			slot "#{name}_alternative_text"
+    		end
+    		def has_many(k,opts={}); @relationships[k] = opts; end
+    	end
+	
+    	# Instance Methods
+
+      attr_accessor :doc, :old_doc, :errors, :is_new
+    	def initialize(document=nil); @errors={}; @doc = document || default_doc; end
+    	def default_doc
+    	  @is_new = true
+    	  out = {}
+    		model.schema.each { |k,v| out.store(k,v[:default].is_a?(Proc) ? v[:default].call : v[:default]) }
+    		out
+    	end
+    	def model; self.class; end
+    	def id; @doc['_id']; end
+    	def [](field); @doc[field]; end
+    	def []=(field,val); @doc[field] = val; end
+    	def to_label;  @doc[model.label_column].to_s.tr("\n\r", ' '); end
+    	def to_param; "#{@doc['_id']}-#{to_label.scan(/\w+/).join('-')}"; end
+      def field_id_for(col); "%s-%s-%s" % [id||'new',model.name,col]; end
+
+    	# relationships
+    	def resolve_class(k); k.kind_of?(Class) ? k : Kernel.const_get(k); end
+    	def parent(k, opts={})
+    	  if k.kind_of?(String)
+    	    key = k
+    	    klass = resolve_class(model.schema[k][:parent_class]) 
+        else
+          klass = resolve_class(k)
+          key = klass.foreign_key_name
+        end
+    	  klass.get(@doc[key], opts)
+    	end
+    	def slot_children(k, opts={})
+    	  if k.kind_of?(String)
+    	    key = k
+    	    klass = resolve_class(model.schema[k][:children_class]) 
+        else
+          klass = resolve_class(k)
+          key = klass.foreign_key_name(true)
+        end
+        ids = (@doc[key]||[]).map{|i| BSON::ObjectId.from_string(i) }
+        selector = {'_id'=>{'$in'=>ids}}
+        sort_proc = proc{ |a,b| ids.index(a['_id'])<=>ids.index(b['_id']) }
+        klass.find(selector, opts).to_a.sort(&sort_proc)
+      end
+      def first_slot_child(k, opts={})
+        if k.kind_of?(String)
+    	    key = k
+    	    klass = resolve_class(model.schema[k][:children_class]) 
+        else
+          klass = resolve_class(k)
+          key = klass.foreign_key_name(true)
+        end
+        klass.get((@doc[key]||[])[0], opts)
+      end
+    	def children(k,opts={})
+    	  k = resolve_class(k)
+    	  slot_name = opts.delete(:slot_name) || model.foreign_key_name
+    	  k.find({slot_name=>@doc['_id'].to_s}, opts)
+    	end
+    	def first_child(k,opts={})
+    	  k = resolve_class(k)
+    	  slot_name = opts.delete(:slot_name) || model.foreign_key_name
+    	  d = k.find_one({slot_name=>@doc['_id'].to_s}, opts)
+    	end
+    	def children_count(k,sel={})
+    	  k = resolve_class(k)
+    	  slot_name = sel.delete(:slot_name) || model.foreign_key_name
+    	  k.collection.count(:query => {slot_name=>@doc['_id'].to_s}.update(sel))
+      end
+
+    	# CRUD
+    	def delete
+    	  before_delete
+    	  model.delete(@doc['_id'])
+    		after_delete
+    	end
+
+    	# saving and hooks
+    	def new?; @is_new ||= !@doc.key?('_id'); end
+    	def update_doc(fields); @old_doc = @doc.dup; @doc.update(fields); @is_new = false; self; end
+    	# Getter and setter in one
+    	def errors_on(col,message=nil)
+    	  message.nil? ? @errors[col] : @errors[col] = (@errors[col]||[]) << message
+      end
+    	def before_delete; @old_doc = @doc.dup; end
+    	alias before_destroy before_delete
+    	def after_delete
+    	  model.relationships.each do |k,v|
+    		  Kernel.const_get(k).find({model.foreign_key_name=>@old_doc['_id'].to_s}).each{|m| m.delete} unless v[:independent]
+    		end
+    	end
+    	alias after_destroy after_delete
+    	def valid?
+    		before_validation
+    		validate
+    		after_validation
+    		@errors.empty?
+    	end
+    	def before_validation
+    	  @errors = {}
+    	  @doc.each do |k,v|
+    	    next unless model.schema.key?(k)
+    			type = k=='_id' ? :primary_key : model.schema[k][:type]
+    	    fix_method = "fix_type_#{type}"
+    	    if v==''
+    	      default = model.schema[k][:default]
+    	      @doc[k] = default.is_a?(Proc) ? default.call : default
+          else
+    	      self.__send__(fix_method, k, v) if self.respond_to?(fix_method)
+          end
+        end
+    	end
+    	def validate; end
+    	def after_validation; end
+    	def fix_type_integer(k,v); @doc[k] = v.to_i; end
+    	def fix_type_boolean(k,v); @doc[k] = (v=='true'||v==true) ? true : false; end
+    	def fix_type_date(k,v)
+    	  if v.is_a?(String)
+    	    if v[/\d\d\d\d-\d\d-\d\d/]
+    	      @doc[k] =  ::Time.utc(*v.split('-'))
+          else
+    	      default = model.schema[k][:default]
+            @doc[k] = default.is_a?(Proc) ? default.call : default
+          end
+    	  end
+    	end
+    	def fix_type_datetime(k,v)
+    	  if v.is_a?(String)
+    	    if v[/\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d/]
+    	      @doc[k] =  ::Time.utc(*v.split(/[-:\s]/))
+          else
+    	      default = model.schema[k][:default]
+            @doc[k] = default.is_a?(Proc) ? default.call : default
+          end
+    	  end
+    	end
+
+    	def save
+    	  return nil unless valid?
+    		before_save
+    		if new?
+    		  before_create
+    		  id = model.collection.insert(@doc)
+    			@doc['_id'] = id
+    			after_create
+    		else
+    		  before_update
+    		  id = model.collection.update({'_id'=>@doc['_id']}, @doc)
+    			after_update
+    		end
+    		after_save
+    		id.nil? ? nil : self
+    	end
+    	def before_save; end
+    	def before_create; end
+    	def before_update; end
+    	def after_save; end
+    	def after_create; @is_new = false; end
+    	def after_update; end
+
+      # ==========
+      # = Cursor =
+      # ==========
+      module CursorMutation
+        # Extend the cursor provided by the Ruby MongoDB driver
+        # We must keep the regular cursor
+        # so we should extend on demand.
+        # Meaning the cursor object should be extended, not the cursor class.
+        def self.extended(into)
+          into.set_mutant_class
+        end
+        def set_mutant_class
+          @mutant_class = Kernel.const_get(collection.name)
+        end
+        def next
+          n = super
+          n.nil? ? nil : @mutant_class.new(n)
+        end
+        # legacy
+        def each_mutant(&b); each(&b); end
+        def each_mutant_with_index(&b); each_with_index(&b); end
+      end
+
+    end
+  end
+end

data/lib/populate_me/mongo/plug.rb

@@ -0,0 +1,132 @@
+require 'populate_me/mongo/mutation'
+require 'populate_me/mongo/stash'
+require 'populate_me/mongo/crushyform'
+require 'populate_me/mongo/backend_api_plug'
+
+module PopulateMe
+  module Mongo
+    module Plug
+  
+      # This module is the one that plugs the model to the CMS
+  
+    	def self.included(base)
+    	  base.class_eval do
+    	    include PopulateMe::Mongo::Mutation
+    	    include PopulateMe::Mongo::Stash if (base.const_defined?(:WITH_STASH) && base::WITH_STASH)
+    	    include PopulateMe::Mongo::BackendApiPlug
+    	    include PopulateMe::Mongo::Crushyform
+    	    include InstanceMethods
+        end
+    		base.extend(ClassMethods)
+    		base.populate_config = {:nut_tree_class=>'sortable-grid'}
+    	end
+
+      module ClassMethods
+    
+        attr_accessor :populate_config
+    
+        #     def list_view(r)
+        #   @list_options = {:request=>r, :destination=>r.fullpath, :path=>r.script_name, :filter=>r['filter'] }
+        #   @list_options.store(:sortable,sortable_on_that_page?)
+        #   out = list_view_header
+        #   out << many_to_many_picker unless populate_config[:minilist_class].nil?
+        #   out << "<ul class='nut-tree #{'sortable' if @list_options[:sortable]} #{populate_config[:nut_tree_class]}' id='#{self.name}' rel='#{@list_options[:path]}/#{self.name}'>"
+        #   self.find(@list_options[:filter]||{}).each {|m| out << m.to_nutshell }
+        #   out << "</ul>"
+        # end
+		
+    		def sortable_on_that_page?(r)
+          @schema.key?('position') && (@schema['position'][:scope].nil? || (r['filter']||{}).key?(@schema['position'][:scope]))
+        end
+    
+        # def minilist_view
+        #   o = "<ul class='minilist'>\n"
+        #   self.collection.find.each_mutant do |m|
+        #     thumb = m.respond_to?(:to_populate_thumb) ? m.to_populate_thumb('stash_thumb.gif') : m.placeholder_thumb('stash_thumb.gif')
+        #     o << "<li title='#{m.to_label}' id='mini-#{m.id}'>#{thumb}<div>#{m.to_label}</div></li>\n"
+        #   end
+        #   o << "</ul>\n"
+        # end
+    
+        private
+    
+        def image_slot(name='image',opts={})
+    		  super(name,opts)
+    			# First image slot is considered the best populate thumb by default
+    			unless instance_methods.include?(:to_populate_thumb)
+    			  define_method :to_populate_thumb do |style|
+    				  generic_thumb(name, style)
+    				end
+    			end
+    		end
+
+    	end
+  
+      module InstanceMethods
+
+    	  def after_stash(col)
+      	  convert(col, "-resize '100x75^' -gravity center -extent 100x75", 'stash_thumb.gif')
+      	end
+
+        def generic_thumb(img , size='stash_thumb.gif', obj=self)
+          return placeholder_thumb(size) if obj.nil?
+      	  current = obj.doc[img]
+      		if !current.nil? && !current[size].nil?
+      		  "/gridfs/#{current[size]}"
+      		else
+      		  placeholder_thumb(size)
+      		end
+      	end
+	
+      	def placeholder_thumb(size)
+          "/_public/img/placeholder.#{size}"
+        end
+	
+      	def to_nutshell
+      	  {
+      	    'class_name'=>model.name,
+      	    'id'=>@doc['_id'].to_s,
+      	    'foreign_key_name'=>model.foreign_key_name,
+      	    'title'=>self.to_label,
+      	    'thumb'=>self.respond_to?(:to_populate_thumb) ? self.to_populate_thumb('stash_thumb.gif') : nil,
+      	    'children'=>nutshell_children,
+      	  }
+        end
+	
+      	def in_nutshell
+          o = model.list_options
+      		out = "<div class='in-nutshell'>\n"
+      		out << self.to_populate_thumb('nutshell.jpg') if self.respond_to?(:to_populate_thumb)
+      		cols = model.populate_config[:quick_update_fields] || nutshell_backend_columns.select{|col| 
+      		  [:boolean,:select].include?(model.schema[col][:type]) && !model.schema[col][:multiple] && !model.schema[col][:no_quick_update]
+      		}
+      		cols.each do |c|
+      		  column_label = c.to_s.sub(/^id_/, '').tr('_', ' ').capitalize
+      		  out << "<div class='quick-update'><form><span class='column-title'>#{column_label}:</span> #{self.crushyinput(c)}</form></div>\n"
+      	  end
+      		out << "</div>\n"
+        end
+
+      	def nutshell_backend_associations
+      	  model.relationships
+      	end
+  
+        def nutshell_children
+      		nutshell_backend_associations.inject([]) do |arr, (k, opts)|
+      		  unless opts[:hidden]
+        		  klass = Kernel.const_get(k)
+        			arr << {
+        			  'children_class_name'=>k,
+        			  'title'=>opts[:link_text] || "#{klass.human_name}(s)",
+        			  'count'=>self.children_count(klass),
+        			}
+        		end
+      		end
+      	end
+      	
+    	end
+
+    end
+  end
+end
+

data/lib/populate_me/mongo/stash.rb

@@ -0,0 +1,119 @@
+module PopulateMe
+  module Mongo
+    module Stash
+  
+      # This module gives models the ability to deal with attachments
+  
+    	def self.included(base)
+    	  Stash.classes << base
+    	  base.extend(ClassMethods)
+    		base.gridfs = GRID
+    	end
+
+      module ClassMethods
+    	  attr_accessor :gridfs
+    	end
+	
+    	# Instance Methods
+	
+    	def build_image_tag(col='image', style='original', html_attributes={})
+    	  return '' if @doc[col].nil?||@doc[col][style].nil?
+    	  title_field, alt_field = col+'_tooltip', col+'_alternative_text'
+    		title = @doc[title_field] if model.schema.keys.include?(title_field)
+    		alt = @doc[alt_field] if model.schema.keys.include?(alt_field)
+    		html_attributes = {:src => "/gridfs/#{@doc[col][style]}", :title => title, :alt => alt}.update(html_attributes)
+    		html_attributes = html_attributes.map do |k,v|
+    		  %{#{k}="#{model.html_escape(v.to_s)}"}
+    		end.join(' ')
+    	  "<img #{html_attributes} />"
+    	end
+
+    	def fix_type_attachment(k,v)
+    	  if v=='nil'
+          delete_files_for(k) unless new?
+    			@doc[k] = nil
+    	  elsif v.is_a?(Hash)&&v.key?(:tempfile)
+    		  delete_files_for(k) unless new?
+    			@temp_attachments ||= {}
+    			@temp_attachments[k] = v
+          attachment_id = model.gridfs.put(v[:tempfile], {:filename=>v[:filename], :content_type=>v[:type]})
+    			@doc[k] = {'original'=>attachment_id}
+    		end
+    	end
+
+    	def delete_files_for(col)
+    	  obj = (@old_doc||@doc)[col]
+    		if obj.respond_to?(:each)
+    		  obj.each do |k,v|
+    			  model.gridfs.delete(v)
+    			end
+    		end
+    	end
+
+    	def after_delete
+    	  super
+        model.schema.each do |k,v|
+    		  delete_files_for(k) if v[:type]==:attachment
+    		end
+    	end
+
+    	def after_save
+    	  super
+    		unless @temp_attachments.nil?
+    			@temp_attachments.each do |k,v|
+    				after_stash(k)
+    			end
+    		end
+    	end
+
+    	def after_stash(col); end
+
+    	def convert(col, convert_steps, style)
+    	  return if @doc[col].nil?
+    	  if @temp_attachments.nil? || @temp_attachments[col].nil?
+    	    f = GRID.get(@doc[col]['original'])
+    	    return unless f.content_type[/^image\//]
+    	    src = Tempfile.new('MongoStash_src')
+    	    src.binmode
+    	    src.write(f.read(4096)) until f.eof?
+    	    src.close
+    	    @temp_attachments ||= {}
+    	    @temp_attachments[col] ||= {}
+    	    @temp_attachments[col][:tempfile] = src
+    	    @temp_attachments[col][:type] = f.content_type
+    		else
+    		  return unless @temp_attachments[col][:type][/^image\//]
+    		  src = @temp_attachments[col][:tempfile]
+    		end
+    	  model.gridfs.delete(@doc[col][style]) unless @doc[col][style].nil?
+    		ext = style[/\..*$/]
+    		dest = Tempfile.new(['MongoStash_dest', ext])
+    		dest.binmode
+    		dest.close
+    	  system "convert \"#{src.path}\" #{convert_steps} \"#{dest.path}\""
+    		filename = "#{model.name}/#{self.id}/#{style}"
+    		content_type = Rack::Mime.mime_type(ext) 
+    		attachment_id = model.gridfs.put(dest.open, {:filename=>filename, :content_type=>content_type})
+        @doc[col] = @doc[col].update({style=>attachment_id})
+    		model.collection.update({'_id'=>@doc['_id']}, @doc)
+    		#src.close!
+    		dest.close!
+    	end
+
+    	class << self
+    	  attr_accessor :classes
+    		Stash.classes = []
+    		def all_after_stash
+    		  Stash.classes.each do |m|
+    			  m.collection.find.each do |i|
+    				  m.schema.each do |k,v|
+    					  m.new(i).after_stash(k) if v[:type]==:attachment
+    					end
+    				end
+    			end
+    		end
+    	end
+
+    end
+  end
+end