simply_couch 0.1.0

data/lib/simply_couch/has_attachment.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module SimplyCouch
+  # Drop-in replacement for Paperclip in SimplyCouch/CouchDB models.
+  #
+  # Usage (replaces `include Paperclip::Glue` + `has_attached_file`):
+  #
+  #   class Image
+  #     include SimplyCouch::Model
+  #     include SimplyCouch::HasAttachment
+  #
+  #     has_attachment :file, styles: {
+  #       medium: "354x1000>",
+  #       thumb:  "160x1250>"
+  #     }
+  #
+  #     # Validations (standard Rails, replaces validates_attachment)
+  #     validate :file_content_type_must_be_image
+  #
+  #     private
+  #
+  #     def file_content_type_must_be_image
+  #       return if file.blank?
+  #       unless %w[image/jpeg image/gif image/png].include?(file_content_type)
+  #         errors.add(:file, :invalid_content_type)
+  #       end
+  #     end
+  #   end
+  #
+  # The module auto-declares CouchDB properties for:
+  #   <name>_file_name, <name>_content_type, <name>_file_size, <name>_updated_at
+  #
+  # Files are stored on disk at:
+  #   public/system/<attachment>/<id>/original.<ext>
+  #   public/system/<attachment>/<id>/<style>.<ext>
+  #
+  # Uses MiniMagick (ImageMagick) for thumbnail generation.
+  # Same geometry syntax as Paperclip: "300x300>", "160x1250>", etc.
+  module HasAttachment
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Proxy object returned by attachment getters (e.g. `image.file`).
+    # Mimics the Paperclip::Attachment API that views expect.
+    class Proxy
+      def initialize(record, name)
+        @record = record
+        @name = name
+      end
+
+      def present?
+        @record.send(:"#{@name}_file_name").present?
+      end
+
+      def blank?
+        !present?
+      end
+
+      def url(style = nil)
+        @record.send(:"#{@name}_url", style)
+      end
+
+      def original_filename
+        @record.send(:"#{@name}_file_name")
+      end
+
+      def content_type
+        @record.send(:"#{@name}_content_type")
+      end
+
+      def size
+        @record.send(:"#{@name}_file_size")
+      end
+
+      # Delegate anything else to the record
+      def method_missing(method, *args, &block)
+        if @record.respond_to?(method, true)
+          @record.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @record.respond_to?(method, include_private) || super
+      end
+    end
+
+    module ClassMethods
+      def has_attachment(name, styles: {}, default_url: nil, default_style: :original)
+        # Auto-declare CouchDB properties for attachment metadata
+        property :"#{name}_file_name"
+        property :"#{name}_content_type"
+        property :"#{name}_file_size", type: Integer
+        property :"#{name}_updated_at", type: Time
+
+        # Register configuration
+        attachment_registry[name] = {
+          styles: styles,
+          default_url: default_url,
+          default_style: default_style,
+        }
+
+        # ---- Setter: model.file = uploaded_file ----
+        define_method(:"#{name}=") do |uploaded|
+          # Handle clearing: nil, empty string
+          if uploaded.nil? || (uploaded.respond_to?(:empty?) && uploaded.empty?)
+            send(:"#{name}_file_name=", nil)
+            send(:"#{name}_content_type=", nil)
+            send(:"#{name}_file_size=", nil)
+            send(:"#{name}_updated_at=", nil)
+            return
+          end
+
+          config = self.class.attachment_registry[name]
+
+          # Extract file info
+          original_filename = if uploaded.respond_to?(:original_filename)
+                                uploaded.original_filename
+                              elsif uploaded.respond_to?(:path)
+                                File.basename(uploaded.path)
+                              else
+                                "file"
+                              end
+          ext = File.extname(original_filename)
+          ext = ".bin" if ext.blank?
+
+          content_type = uploaded.respond_to?(:content_type) ? uploaded.content_type : nil
+          file_size    = uploaded.respond_to?(:size) ? uploaded.size : nil
+
+          # Read content (handle multiple upload types)
+          content = if uploaded.respond_to?(:read)
+                      data = uploaded.read
+                      uploaded.rewind if uploaded.respond_to?(:rewind)
+                      data
+                    elsif uploaded.respond_to?(:path) && File.exist?(uploaded.path)
+                      File.binread(uploaded.path)
+                    elsif uploaded.respond_to?(:tempfile)
+                      uploaded.tempfile.read
+                    else
+                      uploaded.to_s
+                    end
+
+          # Build storage path
+          record_id = respond_to?(:id) && id.present? ? id.to_s : "tmp"
+          base_dir = Rails.root.join("public", "system", name.to_s, record_id)
+          FileUtils.mkdir_p(base_dir)
+
+          begin
+            # Write original file
+            original_path = base_dir.join("original#{ext}")
+            File.binwrite(original_path, content)
+
+            # Generate thumbnail styles
+            config[:styles].each do |style_name, geometry|
+              style_path = base_dir.join("#{style_name}#{ext}")
+              begin
+                image = MiniMagick::Image.open(original_path.to_s)
+                image.resize(geometry)
+                image.write(style_path.to_s)
+              rescue StandardError => e
+                # If ImageMagick fails, copy original as fallback
+                Rails.logger.warn(
+                  "[HasAttachment] Could not generate #{style_name} for #{name}: #{e.message}"
+                )
+                FileUtils.cp(original_path, style_path)
+              end
+            end
+
+            # Store metadata as CouchDB properties
+            send(:"#{name}_file_name=", original_filename)
+            send(:"#{name}_content_type=", content_type)
+            send(:"#{name}_file_size=", file_size || content.bytesize)
+            send(:"#{name}_updated_at=", Time.current)
+          rescue StandardError => e
+            errors.add(name, "could not be processed: #{e.message}")
+            Rails.logger.error("[HasAttachment] Error processing #{name}: #{e.message}")
+          end
+        end
+
+        # ---- Getter: model.file → Proxy ----
+        define_method(name) do
+          Proxy.new(self, name)
+        end
+
+        # ---- URL helper: model.file_url(:thumb) ----
+        define_method(:"#{name}_url") do |style_name = nil|
+          config = self.class.attachment_registry[name]
+          style_name ||= config[:default_style]
+
+          fname = send(:"#{name}_file_name")
+          if fname.blank?
+            return config[:default_url] if config[:default_url]
+            return nil
+          end
+
+          ext = File.extname(fname)
+          record_id = respond_to?(:id) && id.present? ? id.to_s : "tmp"
+
+          "/system/#{name}/#{record_id}/#{style_name}#{ext}"
+        end
+
+        # ---- Backward compat: *_path for Paperclip migrations ----
+        define_method(:"#{name}_path") do |style_name = nil|
+          config = self.class.attachment_registry[name]
+          style_name ||= config[:default_style]
+
+          fname = send(:"#{name}_file_name")
+          return nil if fname.blank?
+
+          ext = File.extname(fname)
+          record_id = respond_to?(:id) && id.present? ? id.to_s : "tmp"
+
+          Rails.root.join("public", "system", name.to_s, record_id, "#{style_name}#{ext}").to_s
+        end
+      end
+
+      # Registry of all attachments defined on this class
+      def attachment_registry
+        @_has_attachment_registry ||= {}
+      end
+    end
+  end
+end

data/lib/simply_couch/include_relation.rb

@@ -0,0 +1,160 @@
+# This file is a tool extension to simply stored. Its intention is to not
+# change anything of an existing implementation, but to hugely speedup existing
+# implementations. I will illustrate this given the example relation types:
+#   Person has_many posts and belongs to a group, Post has many comments, Comment belongs to Writer
+# If for a reason you have one page where you want to display all of these objects
+# (Person, Post, Comment) you can ofcourse create a view returning all these
+# objects with a smart key for some handy selection. This will probably end up
+# in a controller implementation:
+#   @persons = view_result.select{|r| r.is_a?(Person)}
+#   @posts = view_result.select{|r| r.is_a?(Post)}
+#   @comments = view_result.select{|r| r.is_a?(Comment)}
+#   @writers = view_result.select{|r| r.is_a?(Writer)}
+# This probably is the recommended way of solving problems in most cases, but sometimes
+# because you are lazy or some other obscure reason, you want to use the standard
+# SimplyCouch behaviour, but not wait too long. For example, if I have a list of 40 persons,
+# all having 5 posts that all have 10 comments belonging to a writer, getting all these
+# through their standard relations:
+#   @persons.each{ |person| person.posts.each{ |post| post.comments.each{ |comment| puts person.group.name + comment.writer.name } } }
+# This will result in 40 * 5 * 10 + 40 = 2040 queries to the database. Doing exactly the same thing using this script
+# will look like:
+#   @persons = Person.all.include_relation( :group, posts: { conmments: :writer } )
+# The useless script above will not take 2040 queries but:
+#   1 (persons) + 1 (group) + 1 (posts) + 1 (comments) + 1 (write) = 5 queries
+# This makes a difference.
+# Issues:
+# * Supported relation types:
+#   * has_many
+#   * belongs_to
+# * belongs_to relations, that have no value (nil) will be queried again.
+#   That would make the calculation above: 5 + number of persons without a group + number of comments without a writer
+# * Little test coverage
+class Array
+  def include_relation(*relations_arg)
+    return self if empty?
+    relations = {}
+    database = nil
+    database = relations_arg.last.delete(:database) if relations_arg.last.is_a?(Hash) and relations_arg.last.has_key?(:database)
+    database ||= self.first&.class&.database
+    raise ArgumentError, "Cannot include relations without a database — pass :database option or ensure models respond to .database" unless database
+
+    # Make sure relations is a Hash, process up to two levels for recursion
+    # keys with value nil will not have a followup
+    relations_arg.each do |arg|
+      if arg.is_a?(Symbol)
+        relations[arg] = nil
+      elsif arg.is_a?(Hash)
+        arg.each{|k, v| relations[k] = v}
+      elsif arg.is_a?(Array)
+        arg.each do |v|
+          if arg.is_a?(Symbol)
+            relations[v] = nil
+          elsif arg.is_a?(Hash)
+            arg.each{|k, v| relations[k] = v}
+          end
+        end
+      end
+    end
+
+    # For now, assume an array of only one datatype
+    klass = first.class
+
+    relations.each do |relation, followup|
+      property = klass.properties.find{|p| p.name == relation}
+      unless property
+        warn "Attempt to include_relations #{relation} on #{klass.name} but does not have supporting relation", uplevel: 1
+        next
+      end
+      case property
+      when SimplyCouch::Model::HasMany::Property then
+        other_class = property.options[:class_name].constantize
+        other_property = other_class.properties.find{|p| p.is_a?(SimplyCouch::Model::BelongsTo::Property) && p.options[:class_name] == klass.name}
+        #TODO riase when soft_delete is enabled
+        view_name = "by_#{other_property.name}_id"
+        raise "Cannot include has_many relation #{other_class.name.underscore.pluralize} on #{klass.name} when view :#{view_name}, key: :#{other_property.name}_id is not defined on #{other_class.name}" unless other_class.views[view_name].present?
+        relation_objects = other_class.database.view(other_class.send(view_name, keys: collect(&:id))) #not working yet
+        if followup # deeper nested including
+          case followup
+          when Hash
+            then relation_objects.include_relation(followup.merge(database: database))
+          else
+            relation_objects.include_relation(*(Array.wrap(followup) + [{database: database}]))
+          end
+        end
+
+        for obj in self
+          found_relation_objects = relation_objects.select{|r| r.send("#{other_property.name}_id") == obj.id}
+
+          # Make sure every object has a cached value, no more loading is done
+          obj.instance_variable_set("@#{relation}", {all: []}) unless obj.instance_variable_get("@#{relation}").try('[]', :all)
+          if found_relation_objects.any?
+            obj.instance_variable_get("@#{relation}")[:all] |= found_relation_objects
+            if reverse_property_name = other_class.properties.find{|p| p.is_a?(SimplyCouch::Model::BelongsTo::Property) && p.options[:class_name] == klass.name }.try(:name)
+              found_relation_objects.each{|relation_object| relation_object.instance_variable_set("@#{reverse_property_name}", obj)}
+            end
+          end
+        end
+      when SimplyCouch::Model::BelongsTo::Property then
+        key = "#{relation}_id"
+        # Collect keys for all objects
+        keys = []
+        each do |obj|
+          next unless obj.is_a?(SimplyCouch::Model) && obj.respond_to?(key)
+          keys << obj.send(key)
+        end
+
+        # Get from the database
+        relation_objects = database.couchrest_database.bulk_load(keys.compact.uniq)
+        relation_objects = Array.wrap(relation_objects['rows']).map{|r| r['doc']}.compact if relation_objects.is_a?(Hash)
+        relation_objects ||= [] # Ensure array datatype
+        if followup # deeper nested including
+          case followup
+          when Hash
+            then relation_objects.include_relation(followup.merge(database: database))
+          else
+            relation_objects.include_relation(*(Array.wrap(followup) + [{database: database}]))
+          end
+        end
+
+        # Set to attributes
+        each do |obj|
+          obj.instance_variable_set("@#{relation}", relation_objects.find{|o| o.id == obj.send(key)})
+        end
+      when SimplyCouch::Model::HasAndBelongsToMany::Property
+        if property.options[:storing_keys]
+          key = "#{relation.to_s.singularize}_ids"
+          # Collect relation ids for all objects
+          relation_ids = []
+          each do |obj|
+            next unless obj.is_a?(SimplyCouch::Model) && obj.respond_to?(key) && obj.send(key).present?
+            relation_ids += obj.send(key)
+          end
+          # Create unique list of ids, this will optimize stuff and synchronize the object ids
+          relation_ids = relation_ids.flatten.compact.uniq
+
+          # Get from the database
+          relation_objects = database.couchrest_database.bulk_load(relation_ids)
+          relation_objects = Array.wrap(relation_objects['rows']).map{|r| r['doc']}.compact if relation_objects.is_a?(Hash)
+          relation_objects ||= [] # Ensure array datatype
+          each do |obj|
+            obj.instance_variable_set("@#{relation}", {all: relation_objects.select{|o| Array.wrap(obj.send(key)).include?(o.id)}})
+          end
+          if followup # deeper nested including
+            case followup
+            when Hash
+              then relation_objects.include_relation(followup.merge(database: database))
+            else
+              relation_objects.include_relation(*(Array.wrap(followup) + [{database: database}]))
+            end
+          end
+        end
+      end
+    end
+    self
+  end
+
+  # Alias method as plural form
+  def include_relations(*args)
+    include_relation(*args)
+  end
+end