yodel 0.0.1

data/lib/yodel/models/core/record/embedded_record.rb

@@ -0,0 +1,47 @@
+require './record/abstract_record'
+
+class EmbeddedRecord < AbstractRecord
+  attr_reader :embedded_field, :parent_record
+  
+  def initialize(embedded_field, parent_record, values={}, new_record=true)
+    @embedded_field = embedded_field
+    @parent_record = parent_record
+    super(values, new_record)
+  end
+  
+  def site
+    parent_record.site
+  end
+  
+  def set(name, value)
+    super
+    parent_record.changed!(embedded_field.name)
+  end
+  
+  def set_raw(name, value)
+    super
+    parent_record.changed!(embedded_field.name)
+  end
+      
+  def changed!(name)
+    super
+    parent_record.changed!(embedded_field.name)
+  end
+  
+  def fields
+    embedded_field.fields
+  end
+  
+  def perform_save
+    embedded_field.save(self, parent_record)
+  end
+
+  def perform_destroy
+    embedded_field.destroy(self, parent_record)
+  end
+  
+  def perform_reload(id)
+    # TODO: determine whether reloading the parent record will cause any problems
+    self
+  end
+end

data/lib/yodel/models/core/record/mongo_record.rb

@@ -0,0 +1,83 @@
+require './record/abstract_record'
+require './model/mongo_model'
+
+class MongoRecord < AbstractRecord
+  extend MongoModel
+  
+  def fields
+    self.class.fields
+  end
+  
+  def collection
+    self.class.collection
+  end
+  
+  def id
+    @values['_id']
+  end
+  
+  def set_id(new_id)
+    @values['_id'] = new_id
+  end
+
+  def default_values
+    super.merge({'_id' => PrimaryKeyFactory.pk})
+  end
+  
+  def inspect_hash
+    {id: id}.merge(super)
+  end
+
+  def perform_save
+    id = collection.save(@values, safe: true)
+  rescue
+    # TODO: write Yodel.db.get_last_error to the log or as a warning to the site
+    false
+  end
+
+  def perform_destroy
+    result = collection.remove(_id: @values['_id'])
+  rescue
+    false
+  end
+  
+  def perform_reload(params)
+    document = load_mongo_document(_id: params[:id])
+    initialize(document)
+  end
+
+  def load_mongo_document(scope)
+    collection.find_one(scope)
+  end
+
+  def load_from_mongo(scope)
+    @values = load_mongo_document(scope)
+  end
+  
+  def increment!(name, value=1, conditions={})
+    name = name.to_s
+    
+    # preconditions
+    raise DestroyedRecord if destroyed?
+    raise UnknownField, "Unknown field <#{name}>" unless field?(name)
+    return false if new?
+    
+    increment_field = field(name)
+    raise InvalidField, "Field #{name} is not numeric" unless increment_field.numeric?
+    
+    # atomic increment (amount can be negative)
+    conditions = {_id: id}.merge(Plucky::CriteriaHash.new(conditions).to_hash)
+    result = collection.update(conditions, {'$inc' => {name => value}}, safe: true)
+    succeeded = successful_result?(result)
+    
+    # update the object cache, and indicate if the update was successful
+    new_value = (get(name) || 0) + value
+    @values[name] = @typecast[name] = new_value if succeeded
+    succeeded
+  end
+  
+  private
+    def successful_result?(result)
+      result['n'] != 0
+    end
+end

data/lib/yodel/models/core/record/record.rb

@@ -0,0 +1,386 @@
+require './record/abstract_record'
+require './record/embedded_record'
+require './record/mongo_record'
+require './record/site_record'
+require './record/section'
+require './model/model'
+
+class Record < SiteRecord
+  collection    :records
+  attr_reader   :model_record, :model, :mixins
+  attr_accessor :real_record # reference to the 'real' record if this object is a mixin
+
+  def initialize(model, site, values={}, new_record=true)
+    @model_record = model
+    @site = site
+    @model  = load_model(model, values)
+    @mixins = create_mixin_instances(values)
+    super(site, values, new_record)
+
+    # mixins have their db access methods delegated to the "real record"
+    # (the main object representing the mongo document). To maintain a
+    # transparency between objects, key instance variables in the mixin
+    # are changed to refer to the same instance variables in the real record.
+    delegate_mixins
+  end
+
+  def to_str
+    "#<#{model_record.name}: #{id}>"
+  end
+  
+  def default_values
+    super.merge({'model' => model.id})
+  end
+  
+  def collection
+    Record.collection
+  end
+  
+  def perform_reload(params)
+    document = load_mongo_document(_id: params[:id])
+    initialize(params[:model], params[:site], document)
+  end
+  
+  def prepare_reload_params
+    super.tap {|vals| vals[:model] = @model}
+  end
+  
+  
+  # ----------------------------------------
+  # Permissions
+  # ----------------------------------------
+  def user_allowed_to?(user, action)
+    model.user_allowed_to?(user, action, self)
+  end
+
+  def user_allowed_to_view?(user)
+    model.user_allowed_to?(user, :view, self)
+  end
+
+  def user_allowed_to_update?(user)
+    model.user_allowed_to?(user, :update, self)
+  end
+
+  def user_allowed_to_delete?(user)
+    model.user_allowed_to?(user, :delete, self)
+  end
+
+  def user_allowed_to_create?(user)
+    model.user_allowed_to?(user, :create, self)
+  end
+
+  
+  # ----------------------------------------
+  # Modelling
+  # ----------------------------------------
+  def fields
+    @fields ||= @model.all_record_fields
+  end
+  
+  def field_sections
+    if @sections.nil?
+      keyed_sections = Hash.new do |hash, key|
+        hash[key] = Section.new(key)
+      end
+      fields.each do |name, field|
+        keyed_sections[field.section] << field
+      end
+      @sections = keyed_sections.values
+    end
+    
+    @sections
+  end
+  
+  def fields_for_section(section)
+    fields.select do |name, field|
+      field.display? && field.section == section && field.default_input_type.present? && field.default_input_type != :embedded
+    end
+  end
+  
+  def inspect_hash
+    {model: model, parent: parent, index: index}.merge(super)
+  end
+
+  def load_model(model, values)
+    return model if values['eigenmodel'].nil?
+    eigenmodel = site.models.find(values['eigenmodel'])
+    values['eigenmodel'] = nil if eigenmodel.nil?
+    eigenmodel || model
+  end
+  
+  def create_eigenmodel
+    return eigenmodel if eigenmodel?
+    new_eigenmodel = model.create_model("#{id}_eigenmodel")
+    self.eigenmodel = new_eigenmodel
+    @model = new_eigenmodel
+    save
+  end
+  
+  def remove_eigenmodel
+    eigenmodel.destroy if eigenmodel?
+    self.eigenmodel = nil
+    save
+  end
+  
+  def has_eigenmodel?
+    self.eigenmodel != nil
+  end
+  
+  def model_name
+    has_eigenmodel? ? self.eigenmodel.parent.name : self.model_record.name
+  end
+
+  def create_mixin_instances(values)
+    return [] if @model.nil?
+    @model.mixins.collect do |mixin_model|
+      mixin_model.record_class.new(mixin_model, site, values)
+    end.compact
+  end
+
+  def delegate_mixins
+    extend SingleForwardable
+    ancestors = self.class.ancestors
+    included_classes = []
+  
+    mixins.each_with_index do |mixin, index|
+      # reassign the mixin object's instance vars
+      %w{@model @new @site @values @typecast @changed @errors @stash}.each do |var|
+        mixin.instance_variable_set(var, instance_variable_get(var))
+      end
+    
+      # delegate database access to the main object
+      mixin.extend SingleForwardable
+      mixin.real_record = self
+      mixin.def_delegators :@real_record, :save, :save_without_validation, :destroy, :update,
+                                          :reload, :fields
+    
+      # delegate mixin instance methods (if custom classes are used) to the mixin
+      # so mixing in user to a page makes the page appear to have user methods
+      # such as :reset_password. Delegation of methods continues up the class
+      # hierarchy until the class ancestry of the main object and mixin converge
+      # (only unique classes are mixed in). So mixing a user subclass into a page
+      # would mixin the subclass, followed by user. We stop at record since
+      # both page and the user subclass inherit from it.
+      mixin.class.ancestors.each do |klass|
+        break if ancestors.include?(klass)
+        next if included_classes.include?(klass)
+        def_delegators "@mixins[#{index}]", *klass.instance_methods(false)
+        included_classes << klass
+      end
+    end
+  end
+  
+  
+  # ----------------------------------------
+  # Callbacks
+  # ----------------------------------------
+  # extend callbacks to work with mixins
+  Model::CALLBACKS.each do |callback|
+    Model::ORDERS.each do |order|
+      eval "
+        def run_#{order}_#{callback}_callbacks
+          #{order}_completed = self.class._#{order}_#{callback}_callbacks.dup
+          super
+        
+          mixins.collect {|mixin| mixin.class._#{order}_#{callback}_callbacks}.flatten.each do |callback|
+            unless #{order}_completed.include?(callback)
+              send callback
+              #{order}_completed << callback
+            end
+          end
+        end
+      "
+    end
+  end
+  
+  before_validation :run_record_before_validation_callbacks
+  def run_record_before_validation_callbacks
+    model.run_record_before_validation_callbacks(self)
+  end
+
+  after_validation :run_record_after_validation_callbacks
+  def run_record_after_validation_callbacks
+    model.run_record_after_validation_callbacks(self)
+  end
+
+  before_save :run_record_before_save_callbacks
+  def run_record_before_save_callbacks
+    model.run_record_before_save_callbacks(self)
+  end
+
+  after_save :run_record_after_save_callbacks
+  def run_record_after_save_callbacks
+    model.run_record_after_save_callbacks(self)
+  end
+
+  before_create :run_record_before_create_callbacks
+  def run_record_before_create_callbacks
+    model.run_record_before_create_callbacks(self)
+  end
+
+  after_create :run_record_after_create_callbacks
+  def run_record_after_create_callbacks
+    model.run_record_after_create_callbacks(self)
+  end
+
+  before_update :run_record_before_update_callbacks
+  def run_record_before_update_callbacks
+    model.run_record_before_update_callbacks(self)
+  end
+
+  after_update :run_record_after_update_callbacks
+  def run_record_after_update_callbacks
+    model.run_record_after_update_callbacks(self)
+  end
+  
+  before_destroy :run_record_before_destroy_callbacks
+  def run_record_before_destroy_callbacks
+    model.run_record_before_destroy_callbacks(self)
+  end
+
+  after_destroy :run_record_after_destroy_callbacks
+  def run_record_after_destroy_callbacks
+    model.run_record_after_destroy_callbacks(self)
+  end
+  
+  
+  
+  # ----------------------------------------
+  # Hierarchical methods
+  # ----------------------------------------
+  # insertion and deletion to maintin the integrity of the 'index' field
+  before_validation :append_to_siblings
+  before_destroy    :remove_from_siblings
+  before_destroy    :destroy_children
+  
+  def append_to_siblings
+    return unless new?
+    highest_index = siblings.last.try(:index) || 0
+    self.index = highest_index + 1
+  end
+
+  # FIXME: these need to be atomic ops over the whole set of children
+  # FIXME: it also seems weird to perform increments on siblings, but leave the index change to this record unchanged
+  def insert_in_siblings(new_index)
+    original_parent = self.parent
+    remove_from_siblings if index
+    self.parent = original_parent
+    siblings.where(:index.gte => new_index).each do |sibling|
+      sibling.increment!(:index)
+    end
+    self.index = new_index
+  end
+
+  def remove_from_siblings
+    siblings.where(:index.gte => index).each do |sibling|
+      sibling.increment!(:index, -1)
+    end
+    self.index = nil
+    self.parent = nil
+  end
+  
+  def destroy_children
+    children.each(&:destroy)
+  end
+      
+  # Siblings of this record (other records with the same parent)
+  def siblings
+    unless parent.nil?
+      model.unscoped.where(:parent => parent.try(:id), :_id.ne => id).order('index asc')
+    else
+      # A parent ID of nil indicates this record is the root of a tree. Since there
+      # are multiple trees (including the model tree), a sibling query makes no sense.
+      model.unscoped.where(:nonexistant_field => 'true')
+    end
+  end
+  
+  # All direct descendents of this record, and the record itself
+  def children_and_self
+    [self, children].flatten
+  end
+  
+  # All descendent children of this record, i.e children, grandchildren and so on.
+  def all_children
+    [self, children.collect(&:all_children)].flatten
+  end
+
+  # An array of parent records all the way back to a root record. e.g calling on
+  # a page two levels deep would return: [page, parent, root]
+  def parents
+    [self, self.parent.try(:parents)].flatten.compact
+  end
+  
+  # True if this record has no parent
+  def root?
+    parent.nil?
+  end
+  
+  # True if record is a parent (ancestor) of this record
+  def parent?(record)
+    parents.include?(record)
+  end
+  
+  # Returns the first parent which is an instance of type
+  def first_parent(type, exact=false)
+    model = site.model_by_plural_name(type.to_s.downcase.pluralize)
+    
+    if exact
+      match = parents.find {|record| record.model == model}
+    else
+      match = parents.find {|record| record.model.parents_and_mixins.include?(model)}
+    end
+
+    if block_given?
+      yield match
+    else
+      match
+    end
+  end
+  
+  # Finds the first parent which can respond to 'message' and returns the
+  # result. Will return nil if no parents response to the message, however,
+  # keep in mind that nil may be a valid response to this message.
+  def first_response_to(message)
+    message = message.to_s
+    parents.find do |record|
+      return record.send(message) if record.respond_to?(message) || record.fields.keys.include?(message)
+    end
+  end
+  
+  def first_non_blank_response_to(message)
+    message = message.to_s
+    parents.find do |record|
+      if record.respond_to?(message) || record.fields.keys.include?(message)
+        value = record.send(message)
+        return value unless value.blank?
+      end
+    end
+    ''
+  end
+  
+  
+  # ----------------------------------------
+  # Rendering
+  # ----------------------------------------
+  def content
+    @content
+  end
+  
+  def set_content(content)
+    @content = content
+  end
+  
+  def get_binding
+    binding
+  end
+  
+  
+  # ----------------------------------------
+  # Search
+  # ----------------------------------------
+  before_save :update_search_keywords
+  def update_search_keywords
+    return unless model.searchable?
+    self.search_keywords = search_terms
+  end
+end