populate-me 0.0.33 → 0.1.0

data/lib/populate_me/mongo/plug.rb

@@ -1,134 +0,0 @@
-# encoding: utf-8
-
-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.gsub(/^(.*)_([a-zA-Z]+)$/, '\1.\2')}"
-        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

@@ -1,171 +0,0 @@
-# encoding: utf-8
-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
-        def all_after_stash
-          self.collection.find.each do |i|
-            self.schema.each do |k,v|
-              obj = self.new(i)
-              obj.after_stash(k) if v[:type]==:attachment&&obj[k].to_s!=''
-            end
-          end
-        end
-      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.upload_from_stream(
-            v[:filename],
-            v[:tempfile], {
-              :content_type=>v[:type]
-            })
-          @doc[k] = {'original'=>attachment_id}
-        else # Untouched
-          @doc[k] = @old_doc[k]
-        end
-      end
-
-      def delete_files_for(col)
-        obj = (@old_doc||@doc)[col]
-        if obj.respond_to?(:each)
-          obj.each do |k,v|
-            gridfile = model.gridfs.find(_id: v).first
-            model.gridfs.delete(v) unless gridfile.nil?
-          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 = model.gridfs.find({'_id'=>@doc[col]['original']}).first
-          return if f.nil?
-          src = Tempfile.new('MongoStash_src')
-          src.binmode
-          model.gridfs.download_to_stream(@doc[col]['original'], src)
-          return unless f['contentType'].to_s[/^image\//]
-          src.close
-          @temp_attachments ||= {}
-          @temp_attachments[col] ||= {}
-          @temp_attachments[col][:tempfile] = src
-          @temp_attachments[col][:type] = f['contentType']
-        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[/[a-zA-Z]+$/].insert(0,'.')
-        content_type = Rack::Mime.mime_type(ext) 
-        unless content_type[/^image\//]
-          ext = '.jpg'
-          content_type = 'image/jpeg'
-        end
-        dest = Tempfile.new(['MongoStash_dest', ext])
-        dest.binmode
-        dest.close
-        system "convert \"#{src.path}\" #{convert_steps} \"#{dest.path}\""
-        filename = "#{model.name}/#{self.id}/#{style}"
-        attachment_id = model.gridfs.upload_from_stream(
-          filename,
-          dest.open, 
-          {:content_type=>content_type}
-        )
-        @doc[col] = @doc[col].update({style=>attachment_id})
-        model.collection.update_one({'_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.all_after_stash
-          end
-        end
-        
-        def fix_dots_in_keys(c, for_real=false)
-          puts "\n#{c}" unless for_real
-          img_keys = c.schema.select{|k,v| v[:type]==:attachment }.keys
-          c.find({}, {:fields=>img_keys}).each do |e|
-            old_hash = e.doc.select{|k,v| img_keys.include?(k) }
-            fixed_hash = Marshal.load(Marshal.dump(old_hash))
-            img_keys.each do |k|
-              (fixed_hash[k]||{}).keys.each do |style|
-                fixed_hash[k][style.tr('.','_')] = fixed_hash[k].delete(style)
-              end
-            end
-            next if old_hash==fixed_hash
-
-            if for_real
-              c.collection.update_one({'_id'=>e.id}, {'$set'=>fixed_hash})
-            else
-              puts old_hash.inspect
-              puts fixed_hash.inspect
-            end
-
-          end
-        end
-        
-        def all_fix_dots_in_keys(for_real=false)
-          Stash.classes.each do |c|
-            Stash.fix_dots_in_keys(c, for_real)
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/test/spec_ext.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-Encoding.default_internal = Encoding.default_external = Encoding::UTF_8 if RUBY_VERSION >= '1.9.0'
-
-require 'rubygems'
-require 'bacon'
-$:.unshift './lib'
-require "populate_me/ext"
-
-describe 'Integer' do
-  describe '#to_price_string' do
-    should 'Display numbers correctly' do
-      4595.to_price_string.should=='45.95'
-      7000.to_price_string.should=='70'
-      1234567890.to_price_string.should=='12,345,678.90'
-      -140000.to_price_string.should=='-1,400'
-    end
-  end
-end
-
-describe 'String' do
-  describe '#to_price_integer' do
-    should 'Parse numbers correctly' do
-      '28'.to_price_integer.should==2800
-      '45.95'.to_price_integer.should==4595
-      '   £-12,345,678.90   '.to_price_integer.should==-1234567890
-    end
-  end
-end
-

data/test/spec_mongo_mutation.rb

@@ -1,279 +0,0 @@
-# encoding: utf-8
-Encoding.default_internal = Encoding.default_external = Encoding::UTF_8 if RUBY_VERSION >= '1.9.0'
-
-require 'rubygems'
-require 'bacon'
-require 'mongo'
-require 'rack/utils'
-$:.unshift './lib'
-require 'populate_me/mongo'
-
-MONGO = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'test-mongo-mutation')
-class NoDB
-  include PopulateMe::Mongo::Plug
-  def self.human_name; 'No DB'; end
-end
-DB  = MONGO.database
-
-class Naked; include PopulateMe::Mongo::Plug; end
-
-class Person
-  include PopulateMe::Mongo::Plug
-  slot "name" # no options
-  slot "surname"
-  slot "age", :type=>:integer, :default=>18
-  image_slot "portrait"
-  slot 'subscribed_on', :type=>:date, :default=>proc{Time.now}
-end
-
-class Address
-  include PopulateMe::Mongo::Plug
-  slot "body"
-end
-
-class Article
-  include PopulateMe::Mongo::Plug
-  slot 'title'
-  slot 'content', :type=>:text
-  image_slot
-end
-
-class FeatureBox
-  include PopulateMe::Mongo::Plug
-  slot 'header'
-  self.label_column = 'header'
-  def self.human_plural_name; 'Feature Boxes'; end
-end
-
-describe "PopulateMe::Mongo::Mutation" do
-  
-  describe ".db" do 
-    it "Should be set to DB constant by default" do
-      NoDB.db.should==nil
-      Naked.db.should==DB
-    end
-  end
-  
-  shared "Empty Hash" do
-    it "Should be set to an empty hash by default" do
-      @bson.class.should==Hash
-      @bson.empty?.should==true
-    end
-  end
-  
-  describe ".schema" do
-    before { @bson = Naked.schema }
-    behaves_like "Empty Hash"
-  end
-  
-  describe ".relationships" do
-    before { @bson = Naked.relationships }
-    behaves_like "Empty Hash"
-  end
-
-  describe ".human_name" do
-    it "Returns a legible version of the class name - override when incorrect" do
-      Article.human_name.should=='Article'
-      FeatureBox.human_name.should=='Feature Box'
-      # No accronym for simplicity
-      # Easier to override when needed
-      NoDB.human_name.should=='No DB'
-    end
-  end
-
-  describe ".human_plural_name" do
-    it "Only adds an 's' to human name - override if needed" do
-      Article.human_plural_name.should=='Articles'
-      # No rules for simplicity
-      # Easier to override when needed
-      FeatureBox.human_plural_name.should=='Feature Boxes'
-      # Here only .human_name was overridden
-      NoDB.human_plural_name.should=='No DBs'
-    end
-  end
-
-  describe ".ref" do
-    it 'Returns a selector for a BSON::ObjectId' do
-      id = BSON::ObjectId.new
-      Address.ref(id).should=={'_id'=>id}
-    end
-    it 'Makes the argument a BSON::ObjectId if it is a valid string' do
-      string_id = '000000000000000000000000'
-      BSON::ObjectId.legal?(string_id).should==true
-      Address.ref(string_id).should=={'_id'=>BSON::ObjectId.from_string(string_id)}
-    end
-    it 'Makes a selector for multiple docs if argument is an Array' do
-      Address.ref([]).should=={'_id'=>{'$in'=>[]}}
-      id = BSON::ObjectId.new
-      string_id = '000000000000000000000000'
-      Address.ref([id,string_id]).should=={'_id'=>{'$in'=>[id,BSON::ObjectId.from_string(string_id)]}}
-    end
-    it 'Just put an empty string in selector for any invalid argument' do
-      Address.ref('abc').should=={'_id'=>''}
-    end
-  end
-  
-  shared "Basic slot" do
-    it "Adds the declared slot to the schema" do
-      @klass.schema.key?(@key).should==true
-    end
-    it "Defines getters and setters" do
-      @klass.new.respond_to?(@key).should==true
-      @klass.new.respond_to?(@key+'=').should==true
-    end
-  end
-  
-  describe ".slot" do
-    before { @klass = Person; @key = 'age' }
-    behaves_like "Basic slot"
-    it "Keeps the options in schema" do
-      Person.schema['age'][:default].should==18
-      Person.schema['age'][:type].should==:integer
-    end
-    it "Sets :type option to :string by default if not provided" do
-      Person.schema['name'][:type].should==:string
-    end
-  end
-  
-  shared "Correctly typed" do
-    it "Has the correct type" do
-      @klass.schema[@key][:type].should==@type
-    end
-  end
-  
-  shared "Image slot" do
-    describe "Reference slot" do
-      before { @type = :attachment }
-      behaves_like "Basic slot"
-      behaves_like "Correctly typed"
-    end
-    describe "Tooltip slot" do
-      before { @key = @key+'_tooltip'; @type = :string }
-      behaves_like "Basic slot"
-      behaves_like "Correctly typed"
-    end
-    describe "Alt text slot" do
-      before { @key = @key+'_alternative_text'; @type = :string }
-      behaves_like "Basic slot"
-      behaves_like "Correctly typed"
-    end
-  end
-  
-  describe ".image_slot" do
-    describe "Name provided" do
-      before { @klass = Person; @key = 'portrait' }
-      behaves_like "Image slot"
-    end
-    describe "Name not provided" do
-      before { @klass = Article; @key = 'image' }
-      behaves_like "Image slot"
-    end
-  end
-
-  # .slug_column
-  # .foreign_key_name
-  # .collection
-  # .find
-  # .find_one
-  # .count
-  # .sorting_order
-  # .sort
-  # .get
-  # .delete
-  # .is_unique
-  # .has_many
-  
-  shared "Has error recipient" do
-    it "Has an empty recipent for errors" do
-      @inst.errors.should=={}
-    end
-  end
-  
-  describe "#initialize" do
-    describe "With fields" do
-      before { @inst = Person.new({'age'=>42, 'name'=>'Bozo', 'car'=>'Jaguar'}) }
-      it "Should be flagged as new if the doc has no _id yet" do
-        @inst.new?.should==true
-      end
-      it "Should not be flagged as new if the doc has an _id" do
-        @inst['_id'] = 'abc'
-        @inst.new?.should==false
-      end
-      it "Should pass all keys to the doc" do
-        @inst['name'].should=='Bozo'
-        @inst['car'].should=='Jaguar'
-      end
-      behaves_like "Has error recipient"
-    end
-    describe "Fresh new one" do
-      before { @inst = Person.new }
-      it "Should be flagged as new" do
-        @inst.new?.should==true
-      end
-      it "Has default values correctly set" do
-        @inst['age'].should==18 # direct value
-        @inst['subscribed_on'].class.should==Time # with proc
-      end
-      behaves_like "Has error recipient"
-    end
-  end
-  
-  describe "#model" do
-    it "Is a shortcut for self.class" do
-      Naked.new.model.should==Naked
-    end
-  end
-
-  describe '#to_label' do
-    it 'Uses a built-in list of slots to pick from for a label' do
-      Person.new({'age'=>42, 'name'=>'Bozo', 'surname'=>'Montana', 'car'=>'Jaguar'}).to_label.should=='Montana'
-    end
-    it 'Uses an other slot declared with label_column=' do
-      FeatureBox.new({'header'=>'Glamour'}).to_label.should=='Glamour'
-    end
-  end
-
-  describe '#auto_slug' do
-    it 'Should build a url friendly slug based on #to_label' do
-      FeatureBox.new({'header'=>"Así es la vida by Daniel Bär & Mickaël ? (100%)"}).auto_slug.should=='Asi-es-la-vida-by-Daniel-Bar-and-Mickael-100%25'
-    end
-  end
-
-  # #default_doc
-  # #id
-  # #[]
-  # #[]=
-  # #auto_slug
-  # #to_slug
-  # #to_param
-  # #field_id_for
-  # #resolve_class
-  # #parent
-  # #slot_children
-  # #first_slot_child
-  # #children
-  # #first_child
-  # #children_count
-  # #delete
-  # #new?
-  # #update_doc
-  # #errors_on
-  # #valid?
-  # Hooks
-  # Validation
-  # Fix types
-  # #save
-
-  describe 'CursorMutation' do
-    it 'Should give the correct class of object on iterations' do
-      Address.new('body'=>'42').save
-      Address.find.each do |a|
-        a.model.name.should=='Address'
-      end
-    end
-  end
-
-end
-
-DB.drop
-