populate-me 0.12.0

data/lib/populate_me/file_system_attachment.rb

@@ -0,0 +1,40 @@
+require 'populate_me/attachment'
+
+module PopulateMe
+
+  class FileSystemAttachment < Attachment
+
+    set :root, File.expand_path('public')
+    
+    def next_available_filename filename
+      FileUtils.mkdir_p self.location_root
+      ext = File.extname(filename)
+      base = File.basename(filename,ext)
+      i = 0
+      loop do
+        suffix = i==0 ? '' : "-#{i}"
+        potential_filename = [base,suffix,ext].join
+        potential_location = self.location_for_filename(potential_filename)
+        if File.exist?(potential_location)
+          i += 1
+        else
+          filename = potential_filename
+          break
+        end
+      end
+      filename
+    end
+
+    def perform_create hash
+      return File.basename(hash[:variation_path]) unless WebUtils.blank?(hash[:variation_path])
+      source = hash[:tempfile].path
+      filename = self.next_available_filename hash[:filename]
+      destination = self.location_for_filename filename
+      FileUtils.cp source, destination
+      filename
+    end
+
+  end
+
+end
+

data/lib/populate_me/grid_fs_attachment.rb

@@ -0,0 +1,103 @@
+require 'populate_me/attachment'
+require 'mongo'
+require 'rack/grid_serve'
+
+module PopulateMe
+
+  class MissingMongoDBError < StandardError; end
+
+  class GridFSAttachment < Attachment
+
+    # set :url_prefix, '/attachment'
+
+    # Attachee_prefix is moved on field_value for gridfs
+    def url variation_name=:original
+      return nil if WebUtils.blank?(self.field_filename(variation_name))
+      "#{settings.url_prefix.sub(/\/$/,'')}/#{self.field_filename(variation_name)}"
+    end
+    # Attachee_prefix is moved on field_value for gridfs
+    def location_root
+      File.join(
+        settings.root, 
+        settings.url_prefix
+      )
+    end
+
+    def next_available_filename filename
+      ext = File.extname(filename)
+      base = "#{attachee_prefix}/#{File.basename(filename,ext)}"
+      i = 0
+      loop do
+        suffix = i==0 ? '' : "-#{i}"
+        potential_filename = [base,suffix,ext].join
+        if settings.db.fs.find(filename: potential_filename).count>0
+          i += 1
+        else
+          filename = potential_filename
+          break
+        end
+      end
+      filename
+    end
+
+    def perform_create hash
+      if hash[:variation].nil?
+        fn = next_available_filename(hash[:filename])
+        file = hash[:tempfile]
+        type = hash[:type]
+      else
+        fn = WebUtils.filename_variation hash[:future_field_value], hash[:variation].name, hash[:variation].ext
+        file = File.open(hash[:variation_path])
+        type = Rack::Mime.mime_type ".#{hash[:variation].ext}"
+      end
+      settings.db.fs.upload_from_stream(
+        fn,
+        file, {
+          content_type: type,
+          metadata: {
+            parent_collection: (self.document.class.respond_to?(:collection) ? self.document.class.collection.name : self.attachee_prefix),
+          }
+        }
+      )
+      file.close unless hash[:variation].nil?
+      fn
+    end
+
+    def deletable? variation_name=:original
+      !WebUtils.blank? self.field_filename(variation_name)
+      # Fine since deleting a non-existent file does not raise an error in mongo
+    end
+
+    def perform_delete variation_name=:original
+      gridfile = settings.db.fs.find(filename: self.field_filename(variation_name)).first
+      settings.db.fs.delete(gridfile['_id']) unless gridfile.nil?
+    end
+
+    class << self
+
+      def ensure_db
+        raise MissingMongoDBError, "Attachment class #{self.name} does not have a Mongo database." if settings.db.nil?
+      end
+
+      def middleware
+        Rack::GridServe
+      end
+
+      def middleware_options
+        [
+          {
+            prefix: settings.url_prefix.dup.gsub(/^\/|\/$/,''), 
+            db: settings.db,
+            # lookup: :path
+          }
+        ]
+      end
+
+    end
+
+  end
+
+  GridFS = GridFSAttachment
+
+end
+

data/lib/populate_me/mongo.rb

@@ -0,0 +1,160 @@
+require 'populate_me/document'
+require 'mongo'
+
+module PopulateMe
+
+  class MissingMongoDBError < StandardError; end
+
+  class Mongo < Document
+    
+    self.settings.instance_eval do
+      def collection_name
+        puts 'yo'
+        if self[:collection_name].respond_to? :call
+          self[:collection_name].call
+        else
+          self[:collection_name]
+        end
+      end
+    end
+
+    class << self
+
+      def inherited sub 
+        super
+        # self.inherited is not useful anymore because we use ::collection_name 
+        # so that the class name exist when this is run.
+        # Which is not the case with dynamically created classes.
+        #
+        # But we'll keep it for legacy code in the meantime.
+        # Decide if we want to keep it.
+        #
+        # If statment is here for dynamically created classes,
+        # because Class.new.name==nil and then it breaks (see tests).
+        unless sub.name.nil?
+          sub.set :collection_name, WebUtils.dasherize_class_name(sub.name)
+        end
+      end
+
+      def collection_name
+        self.settings.collection_name || WebUtils.dasherize_class_name(self.name) 
+      end
+
+      def collection
+        raise MissingMongoDBError, "Document class #{self.name} does not have a Mongo database." if settings.db.nil?
+        settings.db[self.collection_name]
+      end
+
+      def set_id_field
+        field :_id, {type: :id}
+      end
+
+      def sort_by f, direction=1
+        direction = 1 if direction==:asc
+        direction = -1 if direction==:desc
+        if f.is_a?(Hash)
+          @current_sort = f
+        elsif f.is_a?(Array)
+          @current_sort = f.inject({}) do |h,pair| 
+            h.store(pair[0], pair[1])
+            h
+          end
+        else
+          raise(ArgumentError) unless [1,-1].include? direction
+          raise(ArgumentError) unless self.new.respond_to? f
+          @current_sort = {f => direction}
+        end
+        self
+      end
+
+      def id_string_key
+        (self.fields.keys[0]||'_id').to_s
+      end
+
+      def set_indexes f, ids=[]
+        if self.fields[f.to_sym][:direction]==:desc
+          ids = ids.dup.reverse
+        end
+        requests = ids.each_with_index.inject([]) do |list, (theid, i)|
+          theid = string_or_object_id theid
+          list << {update_one: 
+            {
+              filter: {self.id_string_key=>theid}, 
+              update: {'$set'=>{f=>i}}
+            }
+          }
+        end
+        collection.bulk_write requests
+      end
+
+      def admin_get theid
+        return self.admin_get_multiple(theid) if theid.is_a?(Array)
+        theid = string_or_object_id theid
+        self.cast{ collection.find({id_string_key => theid}).first }
+      end
+      alias_method :[], :admin_get
+
+      def admin_get_multiple theids, o={sort: nil}
+        theids = theids.uniq.compact.map{|theid| string_or_object_id(theid) }
+        self.admin_find(o.merge({
+          query: {id_string_key => {'$in' => theids} }
+        }))
+      end
+
+      def admin_find o={}
+        query = o.delete(:query) || {}
+        o[:sort] ||= @current_sort
+        if o.key?(:fields)
+          o[:projection] = o[:fields].inject({}) do |h, f|
+            h[f.to_sym] = 1
+            h
+          end
+          o.delete(:fields)
+        end
+        self.cast{ collection.find(query, o) }
+      end
+
+      def admin_find_first o={}
+        self.admin_find(o.merge({limit: 1}))[0]
+      end
+
+      def admin_distinct field, o={}
+        query = o.delete(:query) || {}
+        self.collection.distinct field, query, o
+      end
+
+      def string_or_object_id theid
+        if BSON::ObjectId.legal?(theid)
+          BSON::ObjectId.from_string(theid)
+        else
+          theid
+        end
+      end
+
+    end
+
+    attr_accessor :_id
+
+    def id; @_id; end
+    def id= value; @_id = value; end
+
+    def perform_create
+      result = self.class.collection.insert_one(self.to_h)
+      if result.ok? and self.id.nil?
+        self.id = result.inserted_id
+      end
+      self.id
+    end
+
+    def perform_update
+      self.class.collection.update_one({'_id'=> self.id}, self.to_h)
+      self.id
+    end
+
+    def perform_delete
+      self.class.collection.delete_one({'_id'=> self.id})
+    end
+    
+  end
+end
+

data/lib/populate_me/s3_attachment.rb

@@ -0,0 +1,120 @@
+require 'populate_me/attachment'
+require 'aws-sdk-s3'
+
+module PopulateMe
+
+  class MissingBucketError < StandardError; end
+
+  class S3Attachment < Attachment
+
+    # For S3 this option behaves a bit differently.
+    # Because S3 file are served directly instead of using a middleware,
+    # the url_prefix is just used in the key name before the attachee_prefix.
+    # It helps saving keys under /public for example which is a common idiom
+    # to save file in a path public by default.
+    # This option can be overriden at the field level.
+    set :url_prefix, '/public'
+
+    # Attachee_prefix is moved on field_value for S3
+    # as well as url_prefix
+    def url variation_name=:original
+      return nil if WebUtils.blank?(self.field_filename(variation_name))
+      "#{settings.bucket.url}/#{self.field_filename(variation_name)}"
+    end
+    # Attachee_prefix is moved on field_value for S3
+    # as well as url_prefix
+    def location_root
+      File.join(
+        settings.root, 
+        settings.url_prefix
+      )
+    end
+
+    def local_url_prefix
+      (
+        self.field_options[:url_prefix] || 
+        self.document.class.settings.s3_url_prefix || 
+        settings.url_prefix
+      ).gsub(/^\/|\/$/,'')
+    end
+
+    def next_available_filename filename
+      ext = File.extname(filename)
+      base = File.join(
+        local_url_prefix, 
+        attachee_prefix, 
+        File.basename(filename,ext)
+      ).gsub(/^\//,'')
+      i = 0
+      loop do
+        suffix = i==0 ? '' : "-#{i}"
+        potential_filename = [base,suffix,ext].join
+        if settings.bucket.object(potential_filename).exists?
+          i += 1
+        else
+          filename = potential_filename
+          break
+        end
+      end
+      filename
+    end
+
+    def perform_create hash
+      if hash[:variation].nil?
+        fn = next_available_filename(hash[:filename])
+        file = hash[:tempfile]
+        type = hash[:type]
+      else
+        fn = WebUtils.filename_variation hash[:future_field_value], hash[:variation].name, hash[:variation].ext
+        file = File.open(hash[:variation_path])
+        type = Rack::Mime.mime_type ".#{hash[:variation].ext}"
+      end
+      settings.bucket.put_object({
+        acl: self.field_options[:acl] || 'public-read',
+        key: fn,
+        content_type: type,
+        body: file,
+        metadata: {
+          parent_collection: (self.document.class.respond_to?(:collection) ? self.document.class.collection.name : self.attachee_prefix),
+        }
+      })
+      file.close unless hash[:variation].nil?
+      fn
+    end
+
+    def deletable? variation_name=:original
+      !WebUtils.blank? self.field_filename(variation_name)
+      # Fine since deleting a non-existent file does not raise an error in S3
+    end
+
+    def perform_delete variation_name=:original
+      s3file = settings.bucket.object(self.field_filename(variation_name))
+      s3file.delete unless s3file.nil?
+    end
+
+    class << self
+
+      def ensure_bucket
+        raise MissingBucketError, "Attachment class #{self.name} does not have an S3 bucket." if settings.bucket.nil?
+      end
+
+      def middleware
+        nil
+      end
+
+      # def middleware_options
+      #   [
+      #     {
+      #       prefix: settings.url_prefix.dup.gsub(/^\/|\/$/,''), 
+      #       db: settings.db,
+      #       # lookup: :path
+      #     }
+      #   ]
+      # end
+
+    end
+
+  end
+
+end
+

data/lib/populate_me/variation.rb

@@ -0,0 +1,38 @@
+module PopulateMe
+
+  class Variation < Struct.new :name, :ext, :job
+        
+    # Simple class to deal with variations of an attachment
+    # Mainly variation of images using ImageMagick
+    # but it could be anything else like creating the pdf version
+    # of a text file
+
+    def initialize name, ext, job_as_proc=nil, &job_as_block
+      super name, ext, job_as_proc||job_as_block
+    end
+
+    class << self
+
+      def new_image_magick_job name, ext, convert_string, options={}
+        o = {
+          strip: true, progressive: true,
+        }.merge(options)
+        defaults = ""
+        defaults << "-strip " if o[:strip]
+        defaults << "-interlace Plane " if o[:progressive] and [:jpg,:jpeg].include?(ext.to_sym)
+        job = lambda{ |src,dst|
+          Kernel.system "convert \"#{src}\" #{defaults}#{convert_string} \"#{dst}\""
+        }
+        self.new name, ext, job
+      end
+
+      def default
+        self.new_image_magick_job(:populate_me_thumb, :jpg, "-flatten -resize '400x225^' -gravity center -extent 400x225")
+      end
+
+    end
+
+  end
+
+end
+