simply_couch 0.1.0

data/lib/simply_couch/instance_methods.rb

@@ -0,0 +1,356 @@
+module SimplyCouch
+  module InstanceMethods
+    def initialize(attributes = {}, &blk)
+      super(_remove_protected_attributes(attributes))
+      blk.call(self) if blk
+    end
+    def ==(other)
+      other.kind_of?(SimplyCouch::Model) && other._id == _id && other._rev == _rev
+    end
+
+    def eql?(other)
+      self.==(other)
+    end
+
+    def save(validate = true)
+      validate = validate[:validate] if validate.is_a?(Hash) && validate.has_key?(:validate)
+      result = retry_on_conflict do
+        retry_on_connection_error do
+          self.class.database.save_document(self, validate)
+        end
+      end
+      # ActiveModel implementations
+      @previously_changed = changes
+      #@changed_attributes.clear
+      return result
+    end
+
+    def save!
+      result = retry_on_conflict do
+        retry_on_connection_error do
+          self.class.database.save_document!(self)
+        end
+      end
+      # ActiveModel implementations
+      @previously_changed = changes
+      #@changed_attributes.clear
+      return result
+    end
+
+    def destroy(override_soft_delete=false)
+      check_and_destroy_dependents
+      if self.class.soft_deleting_enabled? && !override_soft_delete
+        # soft-delete
+        _mark_as_deleted
+      else
+        if self.class.soft_deleting_enabled? && deleted?
+          # really deleting a previously soft-deleted object - skipping callbacks
+          self.class.database.destroy_document(self, false)
+        else # deleting a normal object or a soft-deletable object that was not soft-deleted before
+          self.class.database.destroy_document(self, true)
+        end
+        freeze
+      end
+      self
+    end
+    alias :delete :destroy
+
+    def update_attributes(attributes = {})
+      parent_id_present = attributes.delete(:parent_id) || attributes.delete('parent_id')
+      self.attributes = attributes
+      if parent_id_present
+        if valid?
+          self.parent_id = parent_id_present
+          save # only for return value, revalidate etc.
+        else
+          return false
+        end
+      else
+        save
+      end
+    end
+    alias_method :update, :update_attributes
+
+    def attributes=(attr)
+      super(_remove_protected_attributes(attr))
+    end
+
+    def reload
+      @children = nil
+      @descendants = nil
+      instance = self.class.find(_id, :with_deleted => true)
+      instance.attributes.each do |attribute, value|
+        send "#{attribute}=", value
+      end
+      self._rev = instance._rev
+      self._attachments = instance._attachments # CouchDB internal, not a property
+      clear_changes_information
+      reset_association_caches
+      self
+    end
+
+    def deleted?
+      if self.class.soft_deleting_enabled?
+        !send(self.class.soft_delete_attribute).nil?
+      else
+        false
+      end
+    end
+
+    def serializable_hash(*)
+      {'id' => self.id}.merge attributes
+    end
+
+  protected
+
+    def retry_on_connection_error(max_retries = 2, &blk)
+      retry_count = 0
+      begin
+        blk.call
+      rescue Errno::ECONNREFUSED => e
+        if retry_count < max_retries
+          retry_count += 1
+          retry
+        else
+          raise e
+        end
+      end
+    end
+
+    def retry_on_conflict(max_retries = 2, &blk)
+      retry_count = 0
+      begin
+        _reset_conflict_information
+        blk.call
+      rescue SimplyCouch::Conflict => e
+        if self.class.auto_conflict_resolution_on_save && retry_count < max_retries && try_to_merge_conflict
+          retry_count += 1
+          retry
+        else
+          _decorate_with_conflict_details(e) if e.is_a?(SimplyCouch::Conflict)
+          raise e
+        end
+      end
+    end
+
+    def _decorate_with_conflict_details(exception)
+      if @_conflict_information.present?
+        def exception.metaclass
+          class << self
+            self
+          end
+        end
+        local_conflict_information = @_conflict_information
+        exception.metaclass.send(:define_method, :message){ "409 Conflict - conflict on attributes: #{local_conflict_information.inspect}" }
+      end
+    end
+
+    def try_to_merge_conflict
+      original = self.class.find(id)
+      our_attributes = self.attributes.dup
+      their_attributes = original.attributes.dup
+      _clear_non_relevant_attributes(our_attributes)
+      _clear_non_relevant_attributes(their_attributes)
+      if _merge_possible?(our_attributes, their_attributes)
+        _copy_non_conflicting_attributes(our_attributes, their_attributes)
+        self._rev = original._rev
+        @_document['_rev'] = original._rev if @_document # keep CouchDB cache in sync
+        true
+      else
+        @_conflict_information = _conflicting_attributes(our_attributes, their_attributes)
+        false
+      end
+    end
+
+    def _reset_conflict_information
+      @_conflict_information = nil
+    end
+
+    def _clear_non_relevant_attributes(attr_list)
+      [:updated_at, :created_at, :id, :rev, :_id, :_rev].each do |skipped_attribute|
+        attr_list.delete(skipped_attribute)
+      end
+    end
+
+    def _copy_non_conflicting_attributes(our_attributes, their_attributes)
+      their_attributes.each do |attr_name, their_value|
+        if !self.public_send("#{attr_name}_changed?") && our_attributes[attr_name] != their_value
+          self.public_send("#{attr_name}=", their_value)
+        end
+      end
+    end
+
+    def _merge_possible?(our_attributes, their_attributes)
+      _conflicting_attributes(our_attributes, their_attributes).empty?
+    end
+
+    def _conflicting_attributes(our_attributes, their_attributes)
+      their_attributes.keys.delete_if do |attr_name|
+        _attribute_not_in_conflict?(attr_name, our_attributes[attr_name], their_attributes[attr_name])
+      end
+    end
+
+    def _attribute_not_in_conflict?(attr_name, our_value, their_value)
+      our_value == their_value || # same
+      !self.public_send("#{attr_name}_changed?") || # we didn't change
+      self.public_send("#{attr_name}_changed?") && their_value == self.public_send("#{attr_name}_was") # we changed and they kept the original
+    end
+
+    def reset_association_caches
+      self.class.properties.each do |property|
+        if property.respond_to?(:association?) && property.association?
+          instance_variable_set("@#{property.name}", nil)
+        end
+      end
+    end
+
+    def _remove_protected_attributes(attrs)
+      return {} if attrs.blank?
+      attrs = attrs.dup.stringify_keys
+      (self.class.instance_variable_get(:@_protected_attributes) || []).map(&:to_s).each do |protected_attribute|
+        attrs.delete(protected_attribute)
+      end
+
+      accessible_attributes = (self.class.instance_variable_get(:@_accessible_attributes) || []).map(&:to_s)
+
+      if accessible_attributes.present?
+        attrs.each do |attr_key, attr_value|
+          attrs.delete(attr_key) unless accessible_attributes.include?(attr_key)
+        end
+      end
+
+      attrs
+    end
+
+    def check_and_destroy_dependents
+      self.class.properties.each do |property|
+        if property.respond_to?(:association?) and property.association?
+          if property.is_a?(SimplyCouch::Model::HasAndBelongsToMany::Property)
+            has_and_belongs_to_many_clean_up_after_destroy(property)
+          else
+            next unless property.options[:dependent]
+            next if property.options[:through]
+            dependents = send(property.name, :force_reload => true)
+            dependents = [dependents] unless dependents.is_a?(Array)
+            dependents.reject{|d| d.nil?}.each do |dependent|
+              case property.options[:dependent]
+              when :destroy
+                dependent.destroy
+              when :ignore
+                # skip
+              else
+                # nullify
+                unless dependent.class.soft_deleting_enabled? && dependent.deleted?
+                  foreign_property = self.class.foreign_property
+                  foreign_property_without_namespace = foreign_property.to_s.split('__').last
+                  if dependent.respond_to?("#{foreign_property}=")
+                    dependent.public_send("#{foreign_property}=", nil)
+                  elsif dependent.respond_to?("#{foreign_property_without_namespace}=")
+                    dependent.public_send("#{foreign_property_without_namespace}=", nil)
+                  end
+                  dependent.save(false)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def _default_view_options(options = {})
+      view_options = {:include_docs => true, :reduce => false}
+      view_options[:descending] = options[:descending] if options[:descending]
+      if view_options[:descending]
+        view_options[:startkey] = ["#{id}\u9999"]
+        view_options[:endkey] = [id]
+      else
+        view_options[:startkey] = [id]
+        view_options[:endkey] = ["#{id}\u9999"]
+      end
+      view_options[:limit] = options[:limit] if options[:limit]
+      view_options
+    end
+
+    def find_one_associated(from, to, options = {})
+      options = {
+        :limit => 1,
+        :descending => true
+      }.update(options)
+      find_associated(from, to, options).first
+    end
+
+    def find_associated(from, to, options = {})
+      foreign_key = (options.delete(:foreign_key) || self.class.name.singularize.property_name.foreign_key).to_s.gsub(/_id$/, '')
+      view_options = _default_view_options(options)
+
+      if options[:with_deleted]
+        self.class.database.view(
+          self.class.get_class_from_name(from).public_send(
+            "association_#{from.to_s.singularize.property_name}_belongs_to_#{foreign_key}_with_deleted", view_options))
+      else
+        self.class.database.view(
+          self.class.get_class_from_name(from).public_send(
+            "association_#{from.to_s.singularize.property_name}_belongs_to_#{foreign_key}", view_options))
+      end
+    end
+
+    def get_embedded(*args)
+      puts args.inspect
+      []
+    end
+
+    def count_associated(from, to, options = {})
+      view_options = _default_view_options(options)
+      view_options[:reduce] = true
+      view_options[:include_docs] = false
+
+      if options[:with_deleted]
+        self.class.database.view(
+          self.class.get_class_from_name(from).public_send(
+            "association_#{from.to_s.singularize.property_name}_belongs_to_#{to.name.singularize.property_name}_with_deleted", view_options))
+      else
+        self.class.database.view(
+          self.class.get_class_from_name(from).public_send(
+            "association_#{from.to_s.singularize.property_name}_belongs_to_#{to.name.singularize.property_name}", view_options))
+      end
+    end
+
+    def find_associated_via_join_view(from, to, options = {})
+      foreign_key = options.delete(:foreign_key).to_s.gsub(/_ids$/, '').pluralize
+      view_options = _default_view_options(options)
+
+      if options[:with_deleted]
+        self.class.database.view(
+          self.class.get_class_from_name(from).public_send(
+            "association_#{from.to_s.singularize.property_name}_has_and_belongs_to_many_#{to.name.pluralize.property_name}_with_deleted", view_options))
+      else
+        self.class.database.view(
+          self.class.get_class_from_name(from).public_send(
+            "association_#{from.to_s.singularize.property_name}_has_and_belongs_to_many_#{to.name.pluralize.property_name}", view_options))
+      end
+    end
+
+    def count_associated_via_join_view(from, to, options = {})
+      view_options = _default_view_options(options)
+      view_options[:reduce] = true
+      view_options[:include_docs] = false
+
+      if options[:with_deleted]
+        self.class.database.view(
+          self.class.get_class_from_name(from).public_send(
+            "association_#{from.to_s.singularize.property_name}_has_and_belongs_to_many_#{to.name.pluralize.property_name}_with_deleted", view_options))
+      else
+        self.class.database.view(
+          self.class.get_class_from_name(from).public_send(
+            "association_#{from.to_s.singularize.property_name}_has_and_belongs_to_many_#{to.name.pluralize.property_name}", view_options))
+      end
+    end
+
+    def _mark_as_deleted
+      run_callbacks :destroy do
+        send("#{self.class.soft_delete_attribute}=", Time.now)
+        save(false)
+      end
+    end
+  end
+end

data/lib/simply_couch/locale/en.yml

@@ -0,0 +1,5 @@
+en:
+  errors:
+    messages:
+      taken: is already taken
+      no_parent: should be parent object

data/lib/simply_couch/model/ancestry.rb

@@ -0,0 +1,307 @@
+module SimplyCouch
+  module Model
+    module Ancestry
+      module InstanceMethods
+        def children
+          return @children if @children
+          if root_property = self.class.ancestry_by_property
+            @children = self.class.database.view(self.class.children_view(startkey: [send(root_property), id], endkey: [send(root_property), id, {}], reduce: false))
+          else
+            @children = self.class.database.view(self.class.children_view(startkey: [id], endkey: [id, {}], reduce: false))
+          end
+          @children
+        end
+        def children=(val)
+          @old_descendants = descendants
+          @children = val
+          @children.map(&:subtree) # preload children hierarchy
+          @new_descendants = []
+          for child in @children
+            for descendant in child.descendants
+              @new_descendants << descendant
+            end
+          end
+          @old_descendants.each{|d| d.instance_variable_set('@parent', nil); d.path_ids = [d.id]} # old descendants become root
+          (@old_descendants - @new_descendants).map(&:save) # Persist old descendants not present in new descendants
+
+          # update by_property of children if it differs from parent (locale or ... orther field is required to have the same values)
+          if root_property = self.class.ancestry_by_property
+            self_by_property = send(root_property)
+            for child in @children | @new_descendants
+              child.send("#{root_property}=", self_by_property) if self_by_property != child.send(root_property)
+            end
+          end
+
+          self.class.set_parent(self, @children) # recurring update of parent in subtree of children
+          @descendants = (@children | @new_descendants)
+          clear_cached_ancestors
+
+          # Return wether all children can be saved :)
+          (@descendants).map(&:save).all?
+        end
+
+        # reset cache attributes for ancestors
+        def clear_cached_ancestors
+          ansi = self
+          while ancestor = ansi.instance_variable_get('@parent').presence
+            ancestor.instance_variable_set('@descendants', nil)
+            ancestor.instance_variable_set('@children', nil)
+            ansi = ancestor
+          end
+          self
+        end
+
+        def add_child(child)
+          unless children.include?(child)
+            @children ||= []
+            @children += [child]
+            child.parent = self
+
+            # update by_property of child if it differs from parent
+            if root_property = self.class.ancestry_by_property
+              child.send("#{root_property}=", send(root_property)) if send(root_property) != child.send(root_property)
+            end
+            @descendants = nil # reload descendants if requested
+          end
+          child
+        end
+
+        # Get all descendants
+        def descendants
+          return @descendants if @descendants
+          return @descendants = [] if id.blank?
+          if root_property = self.class.ancestry_by_property
+            @descendants = self.class.database.view(self.class.subtree_view(startkey: [send(root_property), id], endkey: [send(root_property), id, {}], reduce: false)).sort_by!{|d| [d.path_ids.size, d.position]}
+          else
+            @descendants = self.class.database.view(self.class.subtree_view(startkey: [id], endkey: [id, {}], reduce: false)).sort_by{|d| [d.path_ids.size, d.position]}
+          end
+          @children = self.class.build_tree(@descendants)
+          @descendants
+        end
+
+        # Find subtree of a given page and set children with the result (important to get same children object ids as in descendants)
+        def subtree
+          @children = self.class.build_tree(descendants)
+        end
+
+        # Triggered before save
+        def update_tree_path
+          return false unless id
+          newpath = ( (parent && parent.path_ids) || []) + [id]
+          if path_ids != newpath
+            path_ids_will_change!
+            self.path_ids = newpath
+          end
+          self
+        end
+
+        # Triggered after create, because needs id
+        def create_tree_path
+          return false unless id
+          newpath = ( (parent && parent.path_ids) || []) + [id]
+          return true if path_ids == newpath
+          self.path_ids = newpath
+          save
+        end
+
+        def parent
+          return @parent if @parent
+          return @parent = self.class.find(parent_id) if parent_id.present?
+          nil
+        end
+
+        def parent=(val)
+          if @parent != val
+            @parent = val
+            update_tree_path
+            @parent.children += [self] unless @parent.children.include?(self)
+            save
+          end
+          val
+        end
+
+        def parent_id=(val)
+          if parent_id != val.presence
+            @parent = nil
+            @parent_id = val.presence
+            subtree if persisted?
+            path_ids_will_change!
+            if @parent_id
+              @parent = parent
+              self.path_ids = parent.path_ids + [id]
+              self.class.set_parent(self, @children) if persisted?
+            else
+              self.path_ids = [id]
+              self.class.set_parent(self, @children) if persisted?
+            end
+            @descendants.map(&:save) if persisted? && save
+          end
+        end
+
+        def parent_id
+          @parent_id ||= parent_ids.last
+        end
+
+        def parent_ids
+          (path_ids || [])[0..-2]
+        end
+
+        def ancestors
+          return [] unless parent_ids.any?
+          return [parent] if parent_ids.size == 1 # optimization, parent is pre-loaded many times
+          (self.class.database.couchrest_database.bulk_load(parent_ids)['rows'] || []).map{|h| h['doc']}.compact
+        end
+        def parents
+          ancestors
+        end
+
+        def tree_path
+          ancestors + [self]
+        end
+
+        def tree_depth
+          (path_ids || [nil]).size - 1
+        end
+      end
+
+      module TreeBuilder
+
+      end
+
+      # Add ancestry logic to your model
+      #   class Page
+      #     include SimplyCouch::Model
+      #     has_ancestry
+      #   end
+      # or
+      #   class Page
+      #     include SimplyCouch::Model
+      #     property :locale
+      #     has_ancestry by_property: :locale
+      #   end
+      def has_ancestry(options = {})
+        @ancestry_by_property = nil
+        def self.ancestry_by_property
+          @ancestry_by_property
+        end
+        options = {order_by: :position}.merge(options)
+        order_by = case options[:order_by]
+                   when Symbol then "doc['#{options[:order_by]}']"
+                   when Array then "[#{options[:order_by].map{|o| "doc['#{o}']"}.join(', ')}]"
+                   else "doc['position']"
+                   end
+        property :path_ids, type: Array, default: []
+        property :position, type: Integer, default: 0
+        if options[:by_property].present?
+          property options[:by_property] unless property_names.include?(options[:by_property])
+          @ancestry_by_property = options[:by_property]
+          by_property_view_prefix = options[:by_property].present? ? "doc['#{options[:by_property]}'], " : ''
+        end
+
+        view :subtree_view, type: :custom, include_docs: true, map_function: %|function(doc){
+          if(doc['ruby_class'] == '#{name}' && doc.path_ids){
+            for(var i = 0; i < doc.path_ids.length - 1; i++){
+              emit([#{by_property_view_prefix}doc.path_ids[i], #{order_by}], 1);
+            }
+          }
+        }|, reduce_function: "_sum"
+
+        view :children_view, type: :custom, include_docs: true, map_function: %|function(doc){
+          if(doc['ruby_class'] == '#{name}' && doc.path_ids){
+            emit([#{by_property_view_prefix}doc.path_ids.slice(-2,-1)[0], #{order_by}], 1);
+          }
+        }|, reduce_function: "_sum"
+        view :roots_view, conditions: "doc.path_ids && doc.path_ids.length == 1", key: [options[:by_property].presence, options[:order_by]].compact
+        include SimplyCouch::Model::Ancestry::InstanceMethods
+        extend SimplyCouch::Model::Ancestry::ClassMethods
+        before_update :update_tree_path
+        after_create :create_tree_path
+      end
+      module ClassMethods
+        def roots(options = {})
+          if root_property = ancestry_by_property
+            if options.blank?
+              options = {}
+            elsif options.is_a?(Symbol)
+              options = {startkey: [options.to_s], endkey: [options.to_s, {}]}
+            elsif options.is_a?(String)
+              options = {startkey: [options], endkey: [options, {}]}
+            elsif options.keys.include?(root_property)
+              root_key = options.delete(root_property)
+              options[:startkey] = [root_key.to_s]
+              options[:endkey] = [root_key.to_s, {}]
+            end
+          end
+          options[:reduce] = false
+          database.view(roots_view(options))
+        end
+
+        def full_tree(options = {})
+          if root_property = ancestry_by_property
+            if options.blank?
+              records = all
+            elsif options.is_a?(Array)
+              records = options
+            elsif (options.is_a?(Symbol) || options.is_a?(String))
+              records = send("find_all_by_#{root_property}", options.to_s)
+            elsif options.is_a?(Hash) && options.keys.include?(root_property)
+              root_key = options.delete(root_property)
+              records = send("find_all_by_#{root_property}", root_key.to_s)
+            else
+              records = options[:records].presence || all
+            end
+          else
+            records = options.is_a?(Array) ? options : (options.present? && options[:records].presence) || all
+          end
+          build_tree(records) #.first.children
+        end
+
+        # Build a tree from a flat set of pages making use of the path attribute
+        def build_tree(pages = nil)
+          pages ||= all
+          return pages if pages.empty? # Do not process empty array
+          @tree_wrapper = Struct.new(:children).new([]) # Dummy container as traversing begin, contains roots as children
+          old_tree_slice = @tree_wrapper.children
+          new_tree_slice = []
+          pages.sort_by!{|p| [p.path_ids.size, p.position]}
+          root_depth = pages.first.path_ids.size
+          current_depth = root_depth + 1 # Start counting/swapping from one depth deeper than first one
+          for page in pages
+            old_tree_slice << page and next if page.path_ids.size == root_depth # fill first slice with roots
+
+            # Move further if new depth is reached
+            if page.path_ids.size > current_depth
+              old_tree_slice = new_tree_slice
+              new_tree_slice = []
+              current_depth = page.path_ids.size
+            end
+            parent = old_tree_slice.find{|r| r.id == page.path_ids[-2]} # path id before last is parent id
+            next unless parent # page is not associated in tree
+
+            # Initialize children if needed
+            parent.instance_variable_set('@children', []) unless parent.instance_variable_get('@children').is_a?(Array)
+
+            # Avoid database call on deepest children
+            page.instance_variable_set('@children', []) unless page.instance_variable_get('@children').is_a?(Array)
+            parent.instance_variable_get('@children') << page
+            page.instance_variable_set('@parent', parent)
+            page.instance_variable_set('@parent_id', parent.id)
+            new_tree_slice << page
+          end
+
+          #TODO: setting @descendants from cache as option to avoid database call when descendants is required
+          @tree_wrapper.children
+        end
+
+        # Recursive set parents
+        def set_parent(parent, children)
+          for child in children.sort_by!(&:position)
+            child.instance_variable_set('@parent', parent)
+            child.update_tree_path
+            set_parent child, child.children
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simply_couch/model/association_property.rb

@@ -0,0 +1,26 @@
+module SimplyCouch
+  module Model
+    class AssociationProperty
+      attr_reader :name, :options
+
+      def dirty?(object)
+        false
+      end
+
+      def build(object, json)
+      end
+
+      def serialize(json, object)
+      end
+      alias :value :serialize
+
+      def supports_dirty?
+        false
+      end
+
+      def association?
+        true
+      end
+    end
+  end
+end