simply_couch 0.1.0

data/lib/simply_couch/model/attachments.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# CouchDB inline attachment support.
+# Adds put_attachment, fetch_attachment, delete_attachment, and attachment_names
+# to any SimplyCouch model.
+#
+# Usage:
+#   class Invoice
+#     include SimplyCouch::Model
+#     include SimplyCouch::Model::Attachments
+#   end
+#
+#   invoice.put_attachment('invoice.pdf', file, content_type: 'application/pdf')
+#   invoice.fetch_attachment('invoice.pdf') # => file data
+#   invoice.delete_attachment('invoice.pdf')
+#   invoice.attachment_names # => ['invoice.pdf', 'logo.png']
+#
+module SimplyCouch
+  module Model
+    module Attachments
+      def self.included(base)
+        base.after_save :_save_pending_attachments
+      end
+
+      # Upload a file as a CouchDB inline attachment on this document.
+      # The attachment is stored immediately — no need to call save separately.
+      # Returns the CouchDB result hash.
+      def put_attachment(name, file, content_type: 'binary/octet-stream')
+        result = _couchrest_database.put_attachment(
+          to_hash, name, file, content_type: content_type
+        )
+        self._rev = result['rev'] if result['ok']
+        result
+      end
+
+      # Fetch an attachment's binary data from CouchDB.
+      # Returns nil if the attachment doesn't exist.
+      def fetch_attachment(name)
+        _couchrest_database.fetch_attachment(to_hash, name)
+      rescue RestClient::ResourceNotFound
+        nil
+      end
+
+      # Queue an attachment for upload on next save.
+      # Useful when building a new document that hasn't been saved yet
+      # (no _rev available for immediate put_attachment).
+      def add_attachment(name, file, content_type: 'binary/octet-stream')
+        @_pending_attachments ||= {}
+        @_pending_attachments[name] = { file: file, content_type: content_type }
+      end
+
+      # Delete an attachment from this document.
+      # The attachment is removed immediately — no need to call save separately.
+      def delete_attachment(name)
+        result = _couchrest_database.delete_attachment(to_hash, name)
+        self._rev = result['rev'] if result['ok']
+        result
+      end
+
+      # List all attachment names on this document.
+      def attachment_names
+        (_attachments || {}).keys
+      end
+
+      # Check if an attachment exists.
+      def attachment?(name)
+        attachment_names.include?(name.to_s)
+      end
+
+      private
+
+      def _save_pending_attachments
+        return unless @_pending_attachments&.any?
+
+        @_pending_attachments.each do |name, opts|
+          put_attachment(name, opts[:file], content_type: opts[:content_type])
+        end
+        @_pending_attachments = nil
+      end
+
+      def _couchrest_database
+        if respond_to?(:database) && database.respond_to?(:couchrest_database)
+          database.couchrest_database
+        else
+          self.class.database.couchrest_database
+        end
+      end
+    end
+  end
+end

data/lib/simply_couch/model/belongs_to.rb

@@ -0,0 +1,140 @@
+# Gracefully taken from CouchPotato after it has been removed for good.
+module SimplyCouch
+  module Model
+    module BelongsTo
+
+      def belongs_to(name, options = {})
+        check_existing_properties(name, SimplyCouch::Model::BelongsTo::Property)
+        association_property = if name.to_s.index('__')
+                                 # Already defined properly
+                                 name
+                               elsif options[:class_name].present?
+                                 # Determine namespace and replace last argument with given name
+                                 name_hierarchy = options[:class_name].to_s.underscore.split(/\/|::/)
+                                 name_hierarchy[-1] = name
+                                 name_hierarchy.join('__')
+                               elsif rindex = foreign_property.to_s.rindex('__')
+                                 # Make name based on current namespace
+                                 "#{foreign_property[0...rindex]}__#{name}"
+                               else
+                                 # Just return the good old name
+                                 name
+                               end
+
+        map_definition_without_deleted = <<-eos
+          function(doc) {
+            if (doc['ruby_class'] == '#{self.to_s}' && doc['#{name}_id'] != null) {
+              if (doc['#{soft_delete_attribute}'] && doc['#{soft_delete_attribute}'] != null){
+                // "soft" deleted
+              }else{
+                emit([doc.#{name}_id, doc.created_at], 1);
+              }
+            }
+          }
+        eos
+
+        reduce_definition = "_sum"
+        view "association_#{foreign_property}_belongs_to_#{association_property}",
+          :map_function => map_definition_without_deleted,
+          :reduce_function => reduce_definition,
+          :type => :custom,
+          :include_docs => true
+
+        map_definition_with_deleted = <<-eos
+          function(doc) {
+            if (doc['ruby_class'] == '#{self.to_s}' && doc['#{name}_id'] != null) {
+              emit([doc.#{name}_id, doc.created_at], 1);
+            }
+          }
+        eos
+
+        view "association_#{foreign_property}_belongs_to_#{association_property}_with_deleted",
+          :map_function => map_definition_with_deleted,
+          :reduce_function => reduce_definition,
+          :type => :custom,
+          :include_docs => true
+
+        properties << SimplyCouch::Model::BelongsTo::Property.new(self, name, options)
+      end
+
+      class Property #:nodoc:
+        attr_accessor :name, :options
+
+        def initialize(owner_clazz, name, options = {})
+          @name = name
+          @options = {
+            :class_name => owner_clazz.find_association_class_name(name)
+          }.update(options)
+
+          @options.assert_valid_keys(:class_name)
+
+          owner_clazz.class_eval do
+            property :"#{name}_id"
+            alias_method :"#{name}_changed?", :"#{name}_id_changed?"
+
+            define_method name do |*args|
+              local_options = args.last.is_a?(Hash) ? args.last : {}
+              local_options.assert_valid_keys(:force_reload, :with_deleted)
+              forced_reload = local_options[:force_reload] || false
+              with_deleted = local_options[:with_deleted] || false
+
+              return instance_variable_get("@#{name}") unless instance_variable_get("@#{name}").nil? or forced_reload
+
+              if send("#{name}_id").present?
+                # Try to fetch the object. Does not have to be present. When relation dependency is ignore, the id remains.
+                # This will result in a id to a non existent object. Therefore the rescue for object
+                object = self.class.get_class_from_name(name).find(send("#{name}_id"), :with_deleted => with_deleted) rescue nil
+                instance_variable_set("@#{name}",  object)
+              else
+                instance_variable_set("@#{name}",  nil)
+              end
+            end
+
+            define_method "#{name}=" do |value|
+              klass = self.class.get_class_from_name(name)
+              raise ArgumentError, "expected #{klass} got #{value.class}" unless value.nil? || value.is_a?(klass)
+
+              if value
+                # Has many object update
+                value_has_many_name = klass.properties.find{|p| p.is_a?(SimplyCouch::Model::HasMany::Property) && p.options[:class_name] == self.class.name}.try(:name)
+                value.send(value_has_many_name) << self unless !value_has_many_name || value.send(value_has_many_name).include?(self)
+
+                # Has one object update
+                value_has_one_name = klass.properties.find{|p| p.is_a?(SimplyCouch::Model::HasOne::Property) && p.options[:class_name] == self.class.name}.try(:name)
+                value.instance_variable_set("@#{value_has_one_name}", self) unless !value_has_one_name || value.send(value_has_one_name) == self
+              end
+
+              # Mark changed if appropriate
+              # send("#{name}_will_change!") if value != instance_variable_get("@#{name}") is not a persisted property, do not mark as changed
+
+              instance_variable_set("@#{name}", value)
+              if value.nil?
+                send("#{name}_id=", nil)
+              else
+                send("#{name}_id=", value.id)
+              end
+            end
+
+            define_method "#{name}_id=" do |new_foreign_id|
+              super(new_foreign_id)
+              value = instance_variable_get("@#{name}")
+              remove_instance_variable("@#{name}") if instance_variable_defined?("@#{name}") && new_foreign_id != value.try(:id)
+            end
+          end
+        end
+        def build(object, json)
+          object.send "#{name}_id=", json["#{name}_id"]
+        end
+
+        def serialize(json, object)
+          json["#{name}_id"] = object.send("#{name}_id") if object.send("#{name}_id")
+        end
+        alias :value :serialize
+
+        def association?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/simply_couch/model/database.rb

@@ -0,0 +1,209 @@
+module SimplyCouch
+  module Model
+    module Database
+      def database
+        @_simply_couch_database ||= DatabaseInstance.new(full_database_url)
+      end
+
+      # Override this to provide a custom database URL.
+      # In Rails, reads config/couchdb.yml automatically.
+      def couchrest_database_url
+        @_couchrest_database_url || detect_couchdb_url || ENV['COUCHDB_URL'] || 'http://127.0.0.1:5984'
+      end
+
+      def couchrest_database_url=(url)
+        @_couchrest_database_url = url
+      end
+
+      private
+
+      def full_database_url
+        base = couchrest_database_url
+        name = database_name
+        # Only append db name if URL doesn't already include it.
+        # Skip URL scheme slashes (http://) when checking for existing db name.
+        path_part = base.sub(%r{^https?://}, '')
+        if path_part.include?('/')
+          base  # URL already has a database name
+        else
+          "#{base}/#{name}"
+        end
+      end
+
+      def database_name
+        @_database_name || detect_database_name || 'mozo_development'
+      end
+
+      def database_name=(name)
+        @_database_name = name
+      end
+
+      def detect_couchdb_url
+        return unless defined?(Rails) && Rails.root
+        config_path = Rails.root.join('config/couchdb.yml')
+        return unless File.exist?(config_path)
+        config = YAML.safe_load(ERB.new(File.read(config_path)).result, permitted_classes: [Symbol])
+        env_config = config[Rails.env] || config['development']
+        db_url = env_config['database'] if env_config.is_a?(Hash)
+        # Extract host:port from full URL like http://admin:pass@host:port/dbname
+        # Strip database name from full URL, skipping URL scheme
+        db_url&.sub(%r{/([^/]+)$}, '') { $1 if $1.include?('.') || $1.length < 15 }
+      end
+
+      def detect_database_name
+        return unless defined?(Rails) && Rails.root
+        config_path = Rails.root.join('config/couchdb.yml')
+        return unless File.exist?(config_path)
+        config = YAML.safe_load(ERB.new(File.read(config_path)).result, permitted_classes: [Symbol])
+        env_config = config[Rails.env] || config['development']
+        db_url = env_config['database'] if env_config.is_a?(Hash)
+        return unless db_url
+        URI.parse(db_url).path&.sub('/', '')
+      end
+    end
+
+    # Renamed from CompatibilityNote — this is the actual Database class
+    # (separate from the Database module above to avoid naming conflict)
+    class DatabaseInstance
+      attr_reader :couchrest_database
+
+      def initialize(couchrest_database)
+        if couchrest_database.is_a?(String)
+          # URL string — create CouchRest database
+          @couchrest_database = CouchRest.database(couchrest_database)
+        elsif couchrest_database.nil?
+          @couchrest_database = CouchRest.database('http://127.0.0.1:5984')
+        else
+          @couchrest_database = couchrest_database
+        end
+      end
+
+      def view(spec)
+        results = View::ViewQuery.new(
+          couchrest_database,
+          spec.design_document,
+          {spec.view_name => {
+            :map => spec.map_function,
+            :reduce => spec.reduce_function
+          }},
+          (spec.list_name ? {spec.list_name => spec.list_function} : nil),
+          spec.lib,
+          spec.language
+        ).query_view!(spec.view_parameters)
+        processed_results = spec.process_results results
+        processed_results.each do |document|
+          document.database = self if document.respond_to?(:database=)
+        end if processed_results.respond_to?(:each)
+        processed_results
+      end
+
+      def first(spec)
+        spec.view_parameters = spec.view_parameters.merge({:limit => 1})
+        view(spec).first
+      end
+
+      def save_document(document, validate = true)
+        begin
+          if document.new?
+            create_document(document, validate)
+          else
+            update_document(document, validate)
+          end
+        rescue CouchRest::Conflict
+          raise SimplyCouch::Conflict.new
+        end
+      end
+
+      def save_document!(document)
+        save_document(document) || raise("Validations failed: #{document.errors.full_messages}")
+      end
+
+      def load_document(id)
+        raise "Can't load a document without an id (got nil)" if id.nil?
+        instance = couchrest_database.get(id)
+        instance.database = self if instance.respond_to?(:database=)
+        instance
+      end
+
+      def destroy_document(document, run_callbacks = true)
+        if run_callbacks
+          document.run_callbacks :destroy do
+            document._deleted = true
+            couchrest_database.delete_doc document.to_hash
+          end
+        else
+          document._deleted = true
+          couchrest_database.delete_doc document.to_hash
+        end
+        document._id = nil
+        document._rev = nil
+      end
+
+      def bulk_load(ids)
+        response = couchrest_database.bulk_load ids
+        docs = response['rows'].map{|row| row["doc"]}.compact
+        docs.each{|doc| doc.database = self if doc.respond_to?(:database=) }
+        docs
+      end
+
+      def delete_document(document)
+        couchrest_database.delete_doc document.to_hash
+      end
+
+      private
+
+      def create_document(document, validate)
+        document.database = self
+        if validate
+          document.errors.clear
+          return false if false == document.run_callbacks(:validation) do
+            return false if false == document.run_callbacks(:validation_on_create) do
+              return false unless valid_document?(document)
+            end
+          end
+        end
+        return false if false == document.run_callbacks(:save) do
+          return false if false == document.run_callbacks(:create) do
+            res = couchrest_database.save_doc document.to_hash
+            document._rev = res['rev']
+            document._id = res['id']
+          end
+        end
+        true
+      end
+
+      def update_document(document, validate)
+        if validate
+          document.errors.clear
+          return false if false == document.run_callbacks(:validation) do
+            return false if false == document.run_callbacks(:validation_on_update) do
+              return false unless valid_document?(document)
+            end
+          end
+        end
+        return false if false == document.run_callbacks(:save) do
+          return false if false == document.run_callbacks(:update) do
+            if document.changed?
+              res = couchrest_database.save_doc document.to_hash
+              document._rev = res['rev']
+            end
+          end
+        end
+        true
+      end
+
+      def valid_document?(document)
+        original_errors_hash = document.errors.to_hash
+        document.valid?
+        original_errors_hash.each do |k, v|
+          if v.respond_to?(:each)
+            v.each {|message| document.errors.add(k, message)}
+          else
+            document.errors.add(k, v)
+          end
+        end
+        document.errors.empty?
+      end
+    end
+  end
+end

data/lib/simply_couch/model/embedded_in.rb

@@ -0,0 +1,196 @@
+# Gracefully taken from CouchPotato after it has been removed for good.
+module SimplyCouch
+  module Model
+    module EmbeddedIn
+
+      def is_embedded_in(name, options = {})
+        check_existing_properties(name, SimplyCouch::Model::BelongsTo::Property)
+        parent = options[:class_name] || name.to_s.camelize
+        self.name.property_name.pluralize
+
+        map_definition_without_deleted = <<-eos
+          function(doc) {
+            if (doc['ruby_class'] == '#{parent}') {
+              if(typeof(doc['']))
+              if (doc['#{soft_delete_attribute}'] && doc['#{soft_delete_attribute}'] != null){
+                // "soft" deleted
+              }else{
+                emit([doc.#{name.to_s}_id, doc.created_at], 1);
+              }
+            }
+          }
+        eos
+
+        reduce_definition = "_sum"
+
+        view "association_#{self.name.underscore.gsub('/', '__')}_embedded_in_#{name}",
+          :map_function => map_definition_without_deleted,
+          :reduce_function => reduce_definition,
+          :type => :custom,
+          :include_docs => true
+
+        map_definition_with_deleted = <<-eos
+          function(doc) {
+            if (doc['ruby_class'] == '#{self.to_s}' && doc['#{name.to_s}_id'] != null) {
+              emit([doc.#{name.to_s}_id, doc.created_at], 1);
+            }
+          }
+        eos
+
+        view "association_#{self.name.underscore.gsub('/', '__')}_embedded_in_#{name}_with_deleted",
+          :map_function => map_definition_with_deleted,
+          :reduce_function => reduce_definition,
+          :type => :custom,
+          :include_docs => true
+
+        properties << SimplyCouch::Model::EmbeddedIn::Property.new(self, name, options)
+      end
+
+      class Property #:nodoc:
+        attr_accessor :name, :options
+
+        def initialize(owner_clazz, name, options = {})
+          @name = name
+          embedded_in_name = name
+          @options = {
+            :class_name => name.to_s.singularize.camelize
+          }.update(options)
+
+          @options.assert_valid_keys(:class_name)
+
+          # For now restrictions on naming
+          parent_property_name = owner_clazz.name.property_name.pluralize
+
+          owner_clazz.class_eval do
+            property :"#{name}_id"
+            attr_accessor :parent_object
+            property :index
+            @@embedded_in_class_name = name.to_s.camelize
+
+            class << self
+
+              define_method :embedded_in_class_name do
+              #  embedded_in_name.to_s.singularize.camelize
+                @@embedded_in_class_name
+              end
+
+              define_method :belongs_to do |belongs_to_name, *args|
+                super(*([belongs_to_name] + args))
+                # Now override belongs to view
+                view "association_#{foreign_property}_belongs_to_#{belongs_to_name}",
+                  :map_function => %|function(doc){if(doc['ruby_class'] == '#{embedded_in_class_name}' && doc['#{self.name.property_name.pluralize}']){
+                    for(var i in doc.#{self.name.property_name.pluralize}){
+                      if(doc['#{self.name.property_name.pluralize}'][i]['#{belongs_to_name.to_s.foreign_key}']){
+                        emit([doc['#{self.name.property_name.pluralize}'][i]['#{belongs_to_name.to_s.foreign_key}'], doc['created_at']], doc['#{self.name.property_name.pluralize}'][i]);
+                      }
+                    }
+                  }}|,
+                  :reduce_function => %|function(key, values){return values.length}|,
+                  :type => :raw,
+                  :results_filter => lambda{|results| results['rows'].map{|row| d = row['value']; d.parent_object = row['doc']; d.parent_object.send(self.name.property_name.pluralize)[d.index]}},
+                  :include_docs => true
+              end
+
+              define_method :count do |options = {}|
+                database.view(all_documents_for_count(options.merge(:reduce => true)))['rows'].try(:first).try('[]', 'value').to_i
+              end
+            end
+
+            # Make parent object send through original for callbacks
+            define_method :parent_object= do |value|
+              return @parent_object if @parent_object && @parent_object == value
+              @parent_object = value # Prevent circular calls
+              send("#{name}=", value)
+            end
+            # Redefine the equality method, since we are different kind of objects
+            define_method "==" do |value|
+              self.class == value.class && (value.respond_to?(:parent_object) && self.parent_object == value.parent_object) && (value.respond_to?(:index) && self.index == value.index)
+            end
+            view :all_documents_for_count, :type => :raw, :include_docs => false, :map_function => %|function(doc){
+              if(doc['ruby_class'] == '#{name.to_s.singularize.camelize}' && typeof(doc['#{parent_property_name}']) == 'object'){
+                for(var i=0; i < doc['#{parent_property_name}'].length; i++){
+                  emit(doc['#{parent_property_name}'][i]['created_at'], 1);
+                }
+              }
+            }|, :reduce_function => '_sum'
+            view :all_documents, :type => :raw, :include_docs => true, :map_function => %|function(doc){
+              if(doc['ruby_class'] == '#{name.to_s.singularize.camelize}' && typeof(doc['#{parent_property_name}']) == 'object'){
+                for(var i=0; i < doc['#{parent_property_name}'].length; i++){
+                  emit(doc['#{parent_property_name}'][i]['created_at'], doc['#{parent_property_name}'][i]);
+                }
+              }
+            }|, :results_filter => lambda{|results| results['rows'].map{|row| d = row['value']; d.parent_object = row['doc']; d.parent_object.send(parent_property_name)[d.index]}}
+
+
+
+            # For now empty merge. Since value of map function is transformed to object
+            define_method :merge do |*args|
+            end
+
+            define_method :save do |callbacks=true|
+              if !parent_object
+                errors.add(name, 'no_parent')
+                return false
+              end
+              if callbacks
+                _run_save_callbacks do
+                  parent_object.is_dirty if self.dirty?
+                  parent_object.save
+                end
+              else
+                parent_object.is_dirty if self.dirty?
+                parent_object.save
+              end
+            end
+
+            define_method name do |*args|
+              local_options = args.last.is_a?(Hash) ? args.last : {}
+              local_options.assert_valid_keys(:force_reload, :with_deleted)
+              forced_reload = local_options[:force_reload] || false
+              with_deleted = local_options[:with_deleted] || false
+              return parent_object
+            end
+
+            define_method "#{name}=" do |value|
+              return value if instance_variable_get("@#{name}") == value
+              klass = self.class.get_class_from_name(name)
+              raise ArgumentError, "expected #{klass} got #{value.class}" unless value.nil? || value.is_a?(klass)
+
+              if value
+                # Has many object update
+                value_has_many_name = klass.properties.find{|p| p.is_a?(SimplyCouch::Model::HasManyEmbedded::Property) && p.options[:class_name] == self.class.name}.try(:name)
+                value.send("add_#{value_has_many_name.to_s.singularize}", self) unless !value_has_many_name || value.send(value_has_many_name).include?(self)
+
+                # Has one object update
+                #value_has_one_name = klass.properties.find{|p| p.is_a?(SimplyCouch::Model::HasOneEmbedded::Property) && p.options[:class_name] == self.class.name}.try(:name)
+                #value.instance_variable_set("@#{value_has_one_name}", self) unless !value_has_one_name || value.send(value_has_one_name) == self
+              end
+
+              # Mark changed if appropriate
+              send("#{name}_will_change!") if value != parent_object
+
+              instance_variable_set('@parent_object', value)
+              if value.nil?
+                send("#{name}_id=", nil)
+              else
+                send("#{name}_id=", value.id)
+              end
+            end
+          end
+        end
+        def build(object, json)
+          object.send "#{name}_id=", json["#{name}_id"]
+        end
+
+        def serialize(json, object)
+          json["#{name}_id"] = object.send("#{name}_id") if object.send("#{name}_id")
+        end
+        alias :value :serialize
+
+        def association?
+          true
+        end
+      end # Property
+    end
+  end
+end