populate-me 0.0.33 → 0.1.0

data/lib/populate_me/document_mixins/persistence.rb

@@ -0,0 +1,92 @@
+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 = Utils.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=[]
+          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,99 @@
+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?&&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)
+          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 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
+        end
+
+        def label sym # sets the label_field
+          @label_field = sym.to_sym
+        end
+
+        def label_field
+          @label_field || self.fields.keys[1]
+        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.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
+          self.relationships[name] = o
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/populate_me/document_mixins/typecasting.rb

@@ -0,0 +1,60 @@
+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_date k, v
+        if 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 value.is_a? Array
+            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
+

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,127 @@
+require 'populate_me/attachment'
+require 'mongo'
+require 'rack/gridfs'
+
+module PopulateMe
+
+  class MissingMongoDBError < StandardError; end
+
+  class GridFSAttachment < Attachment
+
+    # set :url_prefix, '/attachment'
+
+    def grid
+      self.class.grid
+    end
+
+    def gridfs
+      self.class.gridfs
+    end
+
+    # 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 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
+      # gridfs works with names instead of IDs
+      gridfs.delete self.field_filename(variation_name)
+    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 grid.exist?(filename: potential_filename)
+          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
+      attachment_id = grid.put(
+        file, {
+          filename: fn, 
+          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
+
+    class << self
+
+      def ensure_db
+        raise MissingMongoDBError, "Attachment class #{self.name} does not have a Mongo database." if settings.db.nil?
+      end
+
+      def grid
+        ensure_db
+        unless settings.grid.is_a?(::Mongo::Grid)
+          set :grid, ::Mongo::Grid.new(settings.db) 
+        end
+        settings.grid
+      end
+
+      def gridfs
+        ensure_db
+        unless settings.gridfs.is_a?(::Mongo::GridFileSystem)
+          set :gridfs, ::Mongo::GridFileSystem.new(settings.db) 
+        end
+        settings.gridfs
+      end
+
+      def middleware
+        Rack::GridFS
+      end
+
+      def middleware_options
+        [
+          {
+            prefix: settings.url_prefix.dup, 
+            db: settings.db,
+            lookup: :path
+          }
+        ]
+      end
+
+    end
+
+  end
+
+  GridFS = GridFSAttachment
+
+end
+