congo 0.1.1

data/lib/congo/metadata/association.rb

@@ -0,0 +1,24 @@
+module Congo
+  module Metadata
+    class Association
+      include MongoMapper::EmbeddedDocument
+  
+      key :name, String
+      key :type, String, :default => 'many'
+  
+      validates_presence_of :name, :type, 
+        :message => lambda { I18n.t('congo.errors.messages.empty') }
+        
+      validates_inclusion_of :type, 
+        :within => ['many', 'belongs_to'],
+        :message => lambda { I18n.t('congo.errors.messages.inclusion') }
+  
+      def apply(klass, scope)
+        klass.send(type, name, :class => scope.content_type_as_const(name.classify))
+        if type.to_sym == :belongs_to
+          klass.key name.foreign_key, String
+        end
+      end
+    end
+  end
+end

data/lib/congo/metadata/key.rb

@@ -0,0 +1,40 @@
+module Congo
+  module Metadata
+    class Key
+      include MongoMapper::EmbeddedDocument
+  
+      ## keys
+      key :name, String
+      key :label, String
+      key :type, String, :default => 'String'
+    
+      ## validations
+      validates_presence_of :name, :type, 
+        :message => lambda { I18n.t('congo.errors.messages.empty') }
+    
+      ## callbacks
+      before_validation { |c| c.send(:normalize_name) }
+        
+      def apply(klass, scope)
+        if type == 'File'
+          klass.send(:include, Congo::Grip::HasAttachment) unless klass.include?(Congo::Grip::HasAttachment) # do not add the module twice
+          klass.has_grid_attachment name.to_sym, :path => ":name/:id"
+        else
+          ctype = scope.content_type_as_const(type)
+          klass.key name.to_sym, ctype
+          klass.include_errors_from name.to_sym if ctype.instance_methods.include?('valid?')
+          ctype.apply(klass, scope, name) if ctype.respond_to?('apply')
+        end
+      end
+      
+      private
+      
+      def normalize_name
+        # TODO: find something more robust to convert label to name
+        self.name = self.label.underscore.gsub(' ', '_') if self.name.blank? && self.label
+        self.name.downcase! if self.name
+      end
+
+    end
+  end
+end

data/lib/congo/metadata/validation.rb

@@ -0,0 +1,42 @@
+module Congo
+  module Metadata
+    class Validation
+      include MongoMapper::EmbeddedDocument
+  
+      key :type, String
+      key :key, String
+      key :argument, String
+  
+      validates_presence_of :key, 
+        :message => lambda { I18n.t('congo.errors.messages.empty') }
+        
+      validates_inclusion_of :type, 
+        :within => methods.grep(/^validates_/).map { |m| m.gsub(/^validates_/, '') },
+        :message => lambda { I18n.t('congo.errors.messages.inclusion') }
+  
+      def apply(klass, scope)
+        options = { :message => type_to_i18n }
+        case self.type
+        when 'format_of'
+          options.merge! :with => /#{self.argument}/
+        end        
+        klass.send("validates_#{type}", key, options)
+      end
+      
+      protected
+      
+      def type_to_i18n
+        keyword = (case self.type
+          when 'presence_of' then 'empty'
+          when 'acceptance_of' then 'accepted'
+          when 'associated' then 'invalid'
+          when 'format_of' then 'invalid'
+          when 'length_of' then 'wrong_length'
+          when 'numericality_of' then 'not_a_number'
+          else self.type.gsub('_of', '')
+        end)
+        I18n.t("congo.errors.messages.#{keyword}")
+      end
+    end
+  end
+end

data/lib/congo/migration.rb

@@ -0,0 +1,143 @@
+module Congo
+  module Migration
+    
+    def self.included(model)
+      model.class_eval do
+        include InstanceMethods
+        
+        key :version, Integer, :default => 0
+        
+        many :migrations, :class_name => 'Congo::Migration::Migration', :dependent => :destroy
+        
+        before_save :increment_version_and_build_migration
+      end
+    end
+    
+    module InstanceMethods
+            
+      private
+      
+      def apply_migration(klass)
+        klass.key :_version, Integer, :default => version
+        
+        klass.class_eval <<-EOV
+          def initialize_with_version(attrs={}, from_database = false)
+            initialize_without_version(attrs, from_database)
+                        
+            self.migrate!
+          end
+          
+          alias_method_chain :initialize, :version
+        
+          def out_dated?
+            self._version < content_type.version
+          end
+        
+          def migrate!
+            content_type.send(:migrate!, self)
+          end
+          
+          protected
+          
+          def rename_key(old_key_name, new_key_name)
+            @_mongo_doc ||= self.class.collection.find({ '_id' => self._id }).first
+            @_mongo_doc[new_key_name] = @_mongo_doc[old_key_name]
+            
+            @_mongo_doc.delete(old_key_name)
+          end
+          
+          def drop_key(key_name)
+            @_mongo_doc ||= self.class.collection.find({ '_id' => self._id }).first
+            @_mongo_doc.delete(key_name)
+            self.send(:keys).delete(key_name) rescue nil
+          end
+        EOV
+      end
+      
+      def migrate!(content)
+        return false unless content.out_dated?
+        
+        doc = content.class.collection.find({ '_id' => content._id }).first
+        content.instance_variable_set '@_mongo_doc', doc
+        
+        migrations.each do |migration|
+          if doc['_version'] < migration.version
+            # logger.debug "running migration #{migration.version} / #{migration.inspect}"
+            
+            migration.tasks.each do |task|
+              # logger.debug "...running task #{task['action']}"
+              
+              case task['action'].to_sym
+                when :rename
+                  content.send(:rename_key, task['previous'], task['next'])
+                when :drop
+                  content.send(:drop_key, task['previous'])
+                else
+                  # unknown action
+              end
+            end
+            doc['_version'] = migration.version
+            # logger.debug "finishing migration (#{content.version}) / #{doc.inspect}"
+            # puts "finishing migration (#{migration.version}) / #{doc.inspect}"
+          end
+        end
+        content.class.collection.save(doc)
+                
+        content.attributes = doc
+      end
+      
+      def increment_version_and_build_migration
+        return if self.to_const.count == 0
+
+        current_ids = metadata_keys.collect { |k| k['_id'] }.compact
+        previous_ids = metadata_keys.previous.collect { |k| k['_id'] }.compact
+
+        migration = Migration.new(:version => self.version + 1, :tasks => [])
+
+        # renamed keys ?
+        (previous_ids & current_ids).each do |key_id|
+          current, previous = metadata_keys.find(key_id), metadata_keys.previous.detect { |k| k['_id'] == key_id }
+          if previous['name'] != current['name']
+            migration.tasks << { :action => 'rename', :previous => previous['name'], :next => current['name'] }
+            
+            # check for potential validations relative to the modified key
+            metadata_validations.each do |validation|
+              validation.key = current['name'] if validation.key == previous['name']
+            end
+          end
+        end
+
+        # dropped keys ?
+        (previous_ids - current_ids).each do |key_id|
+          previous = metadata_keys.previous.detect { |k| k['_id'] == key_id }
+          migration.tasks << { :action => 'drop', :previous => previous['name'] }
+          
+          # check for potential validations relative to the dropped key
+          metadata_validations.delete_if { |v| v.key == previous['name'] }
+        end
+        
+        unless migration.empty?
+          self.version += 1
+          self.migrations << migration
+          # logger.debug "incrementing version #{self.version}"
+        end
+      end
+      
+    end
+    
+    class Migration
+      include MongoMapper::EmbeddedDocument
+        
+      ## keys
+      key :version, Integer, :required => true
+      key :tasks, Array, :required => true
+      
+      ## methods 
+      
+      def empty?
+        self.tasks.empty?
+      end
+    end
+    
+  end
+end

data/lib/congo/proxy_scoper.rb

@@ -0,0 +1,18 @@
+module Congo
+  class ProxyScoper
+    
+    include MongoMapper::Document
+
+    acts_as_congo_scoper
+    
+    ## keys
+    key :ext_type, String
+    key :ext_id, Integer
+    
+    ## validations
+    validates_true_for :ext,
+      :logic => lambda { Congo::ProxyScoper.find_by_ext_id_and_ext_type(ext_id, ext_type).nil? },
+      :message => lambda { I18n.t('congo.errors.messages.taken') }
+    
+  end
+end

data/lib/congo/scoper.rb

@@ -0,0 +1,81 @@
+module Congo
+  module Scoper #:nodoc:
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def acts_as_congo_scoper
+        if !self.included_modules.include?(MongoMapper::Document)
+          class_eval <<-EOV
+
+            include Congo::Scoper::InstanceMethods
+
+            def scoper_instance
+              @proxy_scoper ||= Congo::ProxyScoper.find_by_ext_id_and_ext_type(self.id, self.class.name)
+              if @proxy_scoper.nil?
+                @proxy_scoper = Congo::ProxyScoper.create!(:ext_type => self.class.name, :ext_id => self.id)                
+              end
+              @proxy_scoper
+            end
+
+            def content_types
+              scoper_instance.content_types
+            end
+          EOV
+        else
+          class_eval <<-EOV
+          
+            include Congo::Scoper::InstanceMethods
+            
+            many :content_types, :class_name => 'Congo::ContentType', :as => :scope
+            
+            def scoper_instance
+              nil
+            end
+          EOV
+        end
+      end
+    end
+    
+    module InstanceMethods
+      
+      def proxy_scoper?
+        !scoper_instance.nil?
+      end
+      
+      def consts
+        @consts ||= {}
+      end
+            
+      def content_type_as_const(name, method_name = nil)
+        return nil if (Congo::Types.const_defined?(name) rescue nil).nil?
+        return Congo::Types.const_get(name) if Congo::Types.const_defined?(name)
+        return name.constantize if Object.const_defined?(name)
+        
+        unless consts[name]
+          if (type = content_types.find_by_name(name)).nil?
+            type = content_types.find_by_slug(method_name) if method_name
+          end
+          consts[name] = type.to_const rescue nil # This doesn't work because of different instances being used
+        end
+        
+        consts[name]
+      end
+      
+      private
+      
+      def method_missing(method, *args)
+        if ctype = content_type_as_const(method.to_s.classify, method.to_s)
+          meta = proxy_scoper? ? scoper_instance.metaclass : metaclass
+          meta.many method, :class => ctype
+          (proxy_scoper? ? scoper_instance : self).send(method, *args)
+        else
+          super
+        end        
+      end
+    end
+  end
+end
+
+Object.class_eval { include Congo::Scoper }

data/lib/congo/support.rb

@@ -0,0 +1,19 @@
+module MongoMapper
+  module Plugins
+    module Associations
+      class ManyEmbeddedProxy < EmbeddedCollection
+      
+        def replace_with_dirty_mode(values)
+          @_previous_values = @_values
+          replace_without_dirty_mode(values)
+        end
+      
+        def previous
+          @_previous_values || []
+        end
+      
+        alias_method_chain :replace, :dirty_mode
+      end
+    end
+  end
+end

data/lib/congo/types.rb

@@ -0,0 +1,64 @@
+module Congo
+  module Types
+  
+    class Email < String
+    
+      def self.apply(klass, scope, name)
+        klass.class_eval do
+          validates_format_of name.to_sym, 
+            :with => /\A[\w\._%-]+@[\w\.-]+\.[a-zA-Z]{2,4}\z/,
+            :message => lambda { I18n.t('congo.errors.messages.invalid') }
+        end
+      end
+      
+    end
+    
+    class Text < String
+    end
+    
+    class Date < Date
+      
+      def self.apply(klass, scope, name)
+        klass.class_eval <<-EOV
+          
+          def localized_#{name}
+            if self.#{name}
+              self.#{name}.strftime(I18n.t('congo.date.formats.default'))
+            else
+              nil
+            end
+          end
+          
+          def localized_#{name}=(value)
+            self.#{name} = value
+          end
+          
+        EOV
+      end
+      
+      def self.to_mongo(value)
+        date = self.parse_with_i18n(value.to_s)
+        Time.utc(date[:year], date[:mon], date[:mday])
+      end
+
+      def self.from_mongo(value)
+        value.to_date if value.present?
+      end
+      
+      # Patch from http://gist.github.com/179712
+      def self.parse_with_i18n(str)
+        date = ::Date._strptime(str, I18n.t('congo.date.formats.default')) || self._parse(str)
+        date[:year] += self.increment_year(date[:year].to_i) if date[:year]
+        date
+      end
+
+      def self.increment_year(year)
+        if year < 100
+          year < 30 ? 2000 : 1900
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/congo/validation.rb

@@ -0,0 +1,86 @@
+module Congo
+  module Validation
+    
+    def self.included(model)
+      model.class_eval do
+        include InstanceMethods
+        
+        validates_format_of :name, 
+          :with => /^[a-zA-Z][\w\s]*$/, 
+          :message => lambda { I18n.t('congo.errors.messages.invalid') }
+
+        validates_presence_of :name, :scope, 
+          :message => lambda { I18n.t('congo.errors.messages.empty') }
+
+        validates_true_for :name,
+          :logic => :check_uniqueness_of_name,
+          :message => lambda { I18n.t('congo.errors.messages.taken') }
+
+        validates_true_for :name,
+          :key => :allowed_name,
+          :logic => :check_allowed_name,
+          :message => lambda { I18n.t('congo.errors.messages.exclusion') }
+
+        validates_true_for :metadata_keys, 
+          :logic => :validate_metadata_keys, 
+          :message => lambda { I18n.t('congo.errors.messages.invalid') }
+
+        validates_true_for :collection_name, 
+          :logic => lambda { name.present? }, 
+          :message => lambda { I18n.t('congo.errors.messages.empty') }
+
+        validates_true_for :collection_name,
+          :key => :unique_collection_name,
+          :logic => :check_uniqueness_of_collection_name,
+          :message => lambda { I18n.t('congo.errors.messages.taken') }
+
+        validates_true_for :collection_name,
+          :key => :allowed_allowed_name,
+          :logic => :check_allowed_name,
+          :message => lambda { I18n.t('congo.errors.messages.exclusion') }
+      end
+    end
+    
+    module InstanceMethods
+            
+      private
+
+      def validate_metadata_keys
+        return false if metadata_keys.empty?
+
+        # keys should be valid and unique 
+        found_errors, duplicates = false, {}
+        metadata_keys.each do |key|
+          found_errors ||= !key.valid?
+          if duplicates.key?(key.name)
+            key.errors.add(:name, I18n.t('activerecord.errors.messages.taken'))
+            found_errors = true
+          else
+            duplicates[key.name] = key
+          end
+        end
+        !found_errors
+      end
+
+      def check_uniqueness_of(attribute, value)
+        type = self.class.first(:conditions => { :scope_type => scope_type, :scope_id => scope_id, attribute => value })
+        type.nil? || (type && type == self)
+      end
+
+      def check_uniqueness_of_name
+        check_uniqueness_of(:name, name)
+      end
+
+      def check_uniqueness_of_collection_name
+        collection_name.blank? || (collection_name.present? && check_uniqueness_of(:slug, slug))
+      end
+
+      def check_allowed_name
+        return true if name.blank? || scope.nil?
+        methods = scope.is_a?(Congo::ProxyScoper) ? scope.ext_type.constantize.instance_methods : scope.methods
+        !(methods.include?(name.tableize.to_s) || (slug.present? && methods.include?(slug)))
+      end
+
+    end
+  end
+end