active_shrine 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c8a0f75cce6caf34f444f4cc357181d6e84b77ab248de2e0e847542e5eeb20c
-  data.tar.gz: b3c5d383c8f81f8e858e9bdefcd04211129a6fc73305fd1f891b6ccedebf3526
+  metadata.gz: 756c7f37f8450e532d53547e256301bdb3368e6ce8b27248566a051d7a0ab880
+  data.tar.gz: 8d089b85b9a0d4ff6b80b5088f45a35daa2fc3218897a6b02938e507210f10e2
 SHA512:
-  metadata.gz: c710f77147da3af3c770e4122c2bfd079adb0cf6a07db94869c1cc776be556efef142684a5d03904f92f1ab9dda33803e0abed4bcf45998fbd205506f87fe6a4
-  data.tar.gz: ebfdb98f4aba7b62c0942767a0d7e8af0e13d9443e7fb46b76275320219d6c7460faf4555e27b463e3b77d8cacf94ff88c63e37b0f44b73fe41cfde5c140d553
+  metadata.gz: 3b9bfe585f6ded80b0dfa17626eec1a74c6d2fc82e67b519dd0363df5baa6199681e814ca80a9240c18c9b2229aa775efecacf35bb86ba773887f049f8dd68ec
+  data.tar.gz: 351afd5f4ab728e5313e3d57a4691b319ad5ecae8c21cc36b98cc2ccd0806ac13a00fc90545bc98617452bd96a69e183e991ae40b72db2ef8cb27ea62e080cae

data/README.md

@@ -1,51 +1,127 @@
 # ActiveShrine
 
-TODO: Delete this and the text below, and describe your gem
+ActiveShrine integrates Shrine file attachments with Active Record models using a familiar API inspired by Active Storage. It provides a simple, flexible way to manage file uploads in your Rails applications while leveraging Shrine's powerful features.
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/active_shrine`. To experiment with that code, run `bin/console` for an interactive prompt.
+## Features
 
-## Quick Start
+- **Active Storage-like API**: Familiar `has_one_attached` and `has_many_attached` interface
+- **Customizable Uploaders**: Use custom Shrine uploaders with validation, processing, and more
+- **Polymorphic Associations**: Attachments are stored using polymorphic associations
+- **Eager Loading Support**: Prevent N+1 queries with `with_attached_*` scopes
 
-Get ActiveShrine up and running in your Rails application with these simple steps:
+## Installation
 
-1. **Add Plutonium to your Gemfile:**
+Add ActiveShrine to your application's Gemfile:
 
 ```ruby
 gem "active_shrine"
 ```
 
-2. **Bundle Install:**
+Then execute:
 
-```shell
-bundle
+```bash
+$ bundle install
 ```
 
-3. **Install ActiveShrine:**
+Generate and run the migration:
 
-```shell
-rails g active_shrine:install
+```bash
+$ rails generate active_shrine:install
+$ rails db:migrate
 ```
 
-## Usage
+## Basic Usage
+
+Include `ActiveShrine::Model` in your models and declare attachments:
 
 ```ruby
-class Blog < ApplicationRecord
+class User < ApplicationRecord
   include ActiveShrine::Model
 
   has_one_attached :avatar
-  has_many_attached :documents
+  has_many_attached :photos
+end
+```
+
+Work with attachments using a familiar API:
+
+```ruby
+# Attach a file
+user.avatar = File.open("avatar.jpg")
+user.save
+
+# Access the attachment
+user.avatar.url
+user.avatar.content_type
+user.avatar.filename
+
+# Remove the attachment
+user.avatar = nil
+user.save
+```
+
+### Eager Loading
+
+Prevent N+1 queries by eager loading attachments:
+
+```ruby
+# Single attachment
+User.with_attached_avatar
+
+# Multiple attachments
+User.with_attached_photos
+```
+
+## Custom Uploaders
+
+Define custom uploaders with Shrine features and validations:
+
+```ruby
+class ImageUploader < Shrine
+  plugin :validation_helpers
+  plugin :derivatives
+
+  Attacher.validate do
+    validate_max_size 10 * 1024 * 1024
+    validate_mime_type %w[image/jpeg image/png image/webp]
+  end
+  
+  Attacher.derivatives do |original|
+    {
+      small: shrine_derivative(:resize_to_limit, 300, 300),
+      medium: shrine_derivative(:resize_to_limit, 500, 500)
+    }
+  end
+end
+```
+
+Use custom uploaders in your models:
+
+```ruby
+class User < ApplicationRecord
+  include ActiveShrine::Model
+
+  has_one_attached :avatar, uploader: ::ImageUploader
 end
 ```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo:
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+1. Run `bin/setup` to install dependencies
+2. Run `bundle exec rake test` to run the tests
+3. Run `bin/console` for an interactive prompt
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/active_shrine. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/active_shrine/blob/main/CODE_OF_CONDUCT.md).
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/radioactive-labs/active_shrine.
 
 ## License
 

data/lib/active_shrine/attached/changes/create_many.rb

@@ -4,11 +4,12 @@ module ActiveShrine
   module Attached
     module Changes
       class CreateMany # :nodoc:
-        attr_reader :name, :record, :attachables, :pending_uploads
+        attr_reader :name, :record, :attachment_class, :attachables, :pending_uploads
 
-        def initialize(name, record, attachables, pending_uploads: [])
+        def initialize(name, record, attachment_class, attachables, pending_uploads: [])
           @name = name
           @record = record
+          @attachment_class = attachment_class
           @attachables = Array(attachables)
           @pending_uploads = Array(pending_uploads) + subchanges
           attachments
@@ -29,7 +30,7 @@ module ActiveShrine
         end
 
         def build_subchange_from(attachable)
-          Attached::Changes::CreateOneOfMany.new(name, record, attachable)
+          Attached::Changes::CreateOneOfMany.new(name, record, attachment_class, attachable)
         end
 
         def assign_associated_attachments

data/lib/active_shrine/attached/changes/create_one.rb

@@ -7,11 +7,12 @@ module ActiveShrine
   module Attached
     module Changes
       class CreateOne # :nodoc:
-        attr_reader :name, :record, :attachable
+        attr_reader :name, :record, :attachment_class, :attachable
 
-        def initialize(name, record, attachable)
+        def initialize(name, record, attachment_class, attachable)
           @name = name
           @record = record
+          @attachment_class = attachment_class
           @attachable = attachable
 
           attach
@@ -43,7 +44,7 @@ module ActiveShrine
         end
 
         def build_attachment
-          ActiveShrine::Attachment.new(record:, name:)
+          attachment_class.new(record:, name:)
         end
       end
     end

data/lib/active_shrine/attachment.rb

@@ -25,7 +25,6 @@ require "shrine"
 #
 module ActiveShrine
   class Attachment < ActiveRecord::Base
-    include Shrine::Attachment(:file)
     include ActiveModel::Serializers::JSON
 
     self.table_name = "active_shrine_attachments"
@@ -37,8 +36,8 @@ module ActiveShrine
 
     before_save :maybe_store_record
 
-    def url
-      file_url
+    def url(derivative=nil)
+      file_url(derivative) || file_url
     end
 
     def content_type

data/lib/active_shrine/model.rb

@@ -32,12 +32,53 @@ module ActiveShrine
     #   Gallery.with_attached_photos
 
     class_methods do
+      private
+
+      # Resolves or creates a custom attachment class for a given uploader.
+      #
+      # @param uploader [Class] the uploader class (e.g. ::ImageUploader)
+      # @return [Class, String] the resolved attachment class and its name
+      def resolve_attachment_class(uploader)
+        attachment_class_name = "::ActiveShrine::#{uploader}Attachment"
+
+        # Try to find or create the custom attachment class
+        attachment_class = begin
+          attachment_class_name.constantize
+        rescue NameError
+          # Dynamically create a new class that inherits from ActiveShrine::Attachment
+          Class.new(::ActiveShrine::Attachment) do
+            include uploader::Attachment(:file)
+          end.tap do |klass|
+            # Define the class in the ActiveShrine namespace
+            ActiveShrine.const_set(:"#{uploader}Attachment", klass)
+          end
+        end
+
+        [attachment_class, attachment_class_name]
+      end
+
+      public
+
       # Specifies the relation between a single attachment and the model.
       #
       #   class User < ApplicationRecord
       #     has_one_attached :avatar
       #   end
       #
+      # You can specify a custom uploader implementation to use for the attachment:
+      #
+      #  class ImageUploader < Shrine
+      #    plugin :validation_helpers
+      #
+      #     Attacher.validate do
+      #       validate_max_size 10 * 1024 * 1024
+      #     end
+      #   end
+      #
+      #   class User < ApplicationRecord
+      #     has_one_attached :avatar, uploader: ::ImageUploader
+      #   end
+      #
       # There is no column defined on the model side, ActiveShrine takes
       # care of the mapping between your records and the attachment.
       #
@@ -66,7 +107,9 @@ module ActiveShrine
       # When renaming classes that use <tt>has_many</tt>, make sure to also update the class names in the
       # <tt>active_shrine_attachments.record_type</tt> polymorphic type column of
       # the corresponding rows.
-      def has_one_attached(name, class_name: "::ActiveShrine::Attachment", dependent: :destroy, strict_loading: false)
+      def has_one_attached(name, uploader: ::Shrine, dependent: :destroy, strict_loading: false)
+        attachment_class, attachment_class_name = resolve_attachment_class(uploader)
+
         generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
           # frozen_string_literal: true
           def #{name}
@@ -79,17 +122,27 @@ module ActiveShrine
               if attachable.presence.nil?
                 Attached::Changes::DeleteOne.new("#{name}", self)
               else
-                Attached::Changes::CreateOne.new("#{name}", self, attachable)
+                Attached::Changes::CreateOne.new("#{name}", self, #{attachment_class}, attachable)
               end
           end
         CODE
 
-        has_one(:"#{name}_attachment", -> { where(name:) }, class_name:, as: :record, inverse_of: :record,
-          dependent:, strict_loading:)
+        has_one(:"#{name}_attachment",
+          -> { where(name:) },
+          class_name: attachment_class_name,
+          as: :record,
+          inverse_of: :record,
+          dependent: dependent,
+          strict_loading: strict_loading)
 
         scope :"with_attached_#{name}", -> { includes(:"#{name}_attachment") }
 
-        after_save { shrine_attachment_changes[name.to_s]&.save }
+        after_save do
+          shrine_attachment_changes[name.to_s]&.save
+        rescue => e
+          errors.add(name, :invalid, message: "failed to save. Please make sure it is a valid file.")
+          raise ActiveRecord::RecordInvalid.new(self)
+        end
 
         after_commit(on: %i[create update]) { shrine_attachment_changes.delete(name.to_s) }
 
@@ -97,7 +150,7 @@ module ActiveShrine
           :has_one_attached,
           name,
           nil,
-          {dependent:, source: :active_shrine},
+          {dependent: dependent, class_name: attachment_class_name, source: :active_shrine},
           self
         )
         yield reflection if block_given?
@@ -110,6 +163,20 @@ module ActiveShrine
       #     has_many_attached :photos
       #   end
       #
+      # You can specify a custom Shrine implementation to use for the attachments:
+      #
+      #  class ImageUploader < Shrine
+      #    plugin :validation_helpers
+      #
+      #     Attacher.validate do
+      #       validate_max_size 10 * 1024 * 1024
+      #     end
+      #   end
+      #
+      #   class Gallery < ApplicationRecord
+      #     has_many_attached :photos, uploader: ::ImageUploader
+      #   end
+      #
       # There are no columns defined on the model side, ActiveShrine takes
       # care of the mapping between your records and the attachments.
       #
@@ -138,32 +205,44 @@ module ActiveShrine
       # When renaming classes that use <tt>has_many</tt>, make sure to also update the class names in the
       # <tt>active_shrine_attachments.record_type</tt> polymorphic type column of
       # the corresponding rows.
-      def has_many_attached(name, class_name: "::ActiveShrine::Attachment", dependent: :destroy, strict_loading: false)
+      def has_many_attached(name, uploader: ::Shrine, dependent: :destroy, strict_loading: false)
+        _, attachment_class_name = resolve_attachment_class(uploader)
+
         generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
-        # frozen_string_literal: true
-        def #{name}
-          @active_shrine_attached ||= {}
-          @active_shrine_attached[:#{name}] ||= Attached::Many.new("#{name}", self)
-        end
+          # frozen_string_literal: true
+          def #{name}
+            @active_shrine_attached ||= {}
+            @active_shrine_attached[:#{name}] ||= Attached::Many.new("#{name}", self)
+          end
 
-        def #{name}=(attachables)
-          attachables = Array(attachables).compact_blank
-          pending_uploads = shrine_attachment_changes["#{name}"].try(:pending_uploads)
+          def #{name}=(attachables)
+            attachables = Array(attachables).compact_blank
+            pending_uploads = shrine_attachment_changes["#{name}"].try(:pending_uploads)
 
-          shrine_attachment_changes["#{name}"] = if attachables.none?
-            Attached::Changes::DeleteMany.new("#{name}", self)
-          else
-            Attached::Changes::CreateMany.new("#{name}", self, attachables, pending_uploads: pending_uploads)
+            shrine_attachment_changes["#{name}"] = if attachables.none?
+              Attached::Changes::DeleteMany.new("#{name}", self)
+            else
+              Attached::Changes::CreateMany.new("#{name}", self, #{attachment_class}, attachables, pending_uploads: pending_uploads)
+            end
           end
-        end
         CODE
 
-        has_many(:"#{name}_attachments", -> { where(name:) }, class_name:, as: :record, inverse_of: :record,
-          dependent:, strict_loading:)
+        has_many(:"#{name}_attachments",
+          -> { where(name:) },
+          class_name: attachment_class_name,
+          as: :record,
+          inverse_of: :record,
+          dependent: dependent,
+          strict_loading: strict_loading)
 
         scope :"with_attached_#{name}", -> { includes(:"#{name}_attachments") }
 
-        after_save { shrine_attachment_changes[name.to_s]&.save }
+        after_save do
+          shrine_attachment_changes[name.to_s]&.save
+        rescue => e
+          errors.add(name, :invalid, message: "failed to save. Please make sure it is a valid file.")
+          raise ActiveRecord::RecordInvalid.new(self)
+        end
 
         after_commit(on: %i[create update]) { shrine_attachment_changes.delete(name.to_s) }
 
@@ -171,7 +250,7 @@ module ActiveShrine
           :has_many_attached,
           name,
           nil,
-          {dependent:, source: :active_shrine},
+          {dependent: dependent, class_name: attachment_class_name, source: :active_shrine},
           self
         )
         yield reflection if block_given?

data/lib/active_shrine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveShrine
-  VERSION = "0.2.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_shrine
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Radioactive Labs
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-11 00:00:00.000000000 Z
+date: 2025-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -114,7 +114,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".DS_Store"
 - ".rspec"
 - ".ruby-version"
 - CHANGELOG.md
@@ -123,7 +122,6 @@ files:
 - README.md
 - Rakefile
 - config.ru
-- lib/.DS_Store
 - lib/active_shrine.rb
 - lib/active_shrine/attached.rb
 - lib/active_shrine/attached/base.rb
@@ -177,7 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: A compatible ActiveStorage api for attaching Shrine uploads to ActiveRecord