venus_media_library 0.1.0

data/app/controllers/venus_media_library/application_controller.rb

@@ -0,0 +1,19 @@
+module VenusMediaLibrary
+  class ApplicationController < ActionController::Base
+    # Run the host-configured access gate (if any) before every engine action.
+    # The engine ships open; the host restricts the picker/upload endpoints by
+    # setting VenusMediaLibrary.configuration.authenticate_with to a proc.
+    before_action :authenticate_venus_media_library_access!
+
+    private
+
+    def authenticate_venus_media_library_access!
+      gate = VenusMediaLibrary.configuration.authenticate_with
+      return unless gate.respond_to?(:call)
+
+      # instance_exec so the proc runs in this controller's context and can use
+      # host helpers (current_user, redirect_to, head, main_app, ...).
+      instance_exec(&gate)
+    end
+  end
+end

data/app/controllers/venus_media_library/images_controller.rb

@@ -0,0 +1,82 @@
+module VenusMediaLibrary
+  # Lists and uploads images backed by Active Storage. Storage-agnostic: it uses
+  # whatever service the host app configures (Disk in dev, S3 in prod, ...).
+  class ImagesController < ApplicationController
+    include VenusMediaLibrary::ImagesHelper
+
+    # GET /images
+    # Lists image blobs, newest first, with simple offset pagination.
+    # Responds with an HTML grid or a JSON payload for the picker.
+    def index
+      @page     = [ params.fetch(:page, 1).to_i, 1 ].max
+      @per_page = per_page
+      offset    = (@page - 1) * @per_page
+
+      scope        = image_blobs
+      @total_count = scope.count
+      @blobs       = scope.order(created_at: :desc).offset(offset).limit(@per_page).to_a
+      @has_more    = offset + @blobs.size < @total_count
+      @images      = @blobs.map { |blob| ml_image_payload(blob) }
+
+      respond_to do |format|
+        format.html # index.html.erb
+        format.json do
+          render json: { images: @images, page: @page, has_more: @has_more, total: @total_count }
+        end
+      end
+    end
+
+    # POST /images
+    # Accepts an uploaded file and stores it via Active Storage.
+    def create
+      uploaded = params[:file] || params.dig(:image, :file)
+
+      if uploaded.blank?
+        return respond_error("No file was uploaded.", :unprocessable_entity)
+      end
+
+      unless allowed_content_type?(uploaded.content_type)
+        return respond_error("Content type #{uploaded.content_type} is not allowed.", :unprocessable_entity)
+      end
+
+      blob = ActiveStorage::Blob.create_and_upload!(
+        io:           uploaded.tempfile,
+        filename:     uploaded.original_filename,
+        content_type: uploaded.content_type,
+        service_name: VenusMediaLibrary.configuration.storage_service
+      )
+
+      respond_to do |format|
+        format.json { render json: ml_image_payload(blob), status: :created }
+        format.html { redirect_to images_path }
+      end
+    end
+
+    private
+
+    def image_blobs
+      ActiveStorage::Blob.where("content_type LIKE ?", "image/%")
+    end
+
+    def per_page
+      value = params[:per_page].presence&.to_i
+      value && value.positive? ? value : VenusMediaLibrary.configuration.per_page
+    end
+
+    def allowed_content_type?(content_type)
+      return false if content_type.blank?
+
+      allowed = VenusMediaLibrary.configuration.allowed_content_types
+      return content_type.start_with?("image/") if allowed.blank?
+
+      allowed.include?(content_type) || content_type.start_with?("image/")
+    end
+
+    def respond_error(message, status)
+      respond_to do |format|
+        format.json { render json: { error: message }, status: status }
+        format.html { redirect_to images_path, alert: message }
+      end
+    end
+  end
+end

data/app/controllers/venus_media_library/pickers_controller.rb

@@ -0,0 +1,22 @@
+module VenusMediaLibrary
+  # Renders the picker modal body as a Turbo Frame. `target` is the DOM id of the
+  # host input that a chosen image URL / signed_id should be written into.
+  class PickersController < ApplicationController
+    include VenusMediaLibrary::ImagesHelper
+
+    def show
+      @target = params[:target].to_s
+      @page   = [ params.fetch(:page, 1).to_i, 1 ].max
+      per     = VenusMediaLibrary.configuration.per_page
+      offset  = (@page - 1) * per
+
+      scope     = ActiveStorage::Blob.where("content_type LIKE ?", "image/%")
+      @has_more = offset + per < scope.count
+      @images   = scope.order(created_at: :desc).offset(offset).limit(per).map { |blob| ml_image_payload(blob) }
+
+      render partial: "venus_media_library/pickers/picker",
+             locals: { target: @target, images: @images, page: @page, has_more: @has_more },
+             layout: false
+    end
+  end
+end

data/app/helpers/venus_media_library/application_helper.rb

@@ -0,0 +1,4 @@
+module VenusMediaLibrary
+  module ApplicationHelper
+  end
+end

data/app/helpers/venus_media_library/images_helper.rb

@@ -0,0 +1,46 @@
+module VenusMediaLibrary
+  # Shared image URL/payload logic. Included in the views (automatically) and in
+  # ImagesController so the HTML grid and the JSON response stay in sync.
+  module ImagesHelper
+    # A serializable description of a blob used by the JSON API and the tiles.
+    def ml_image_payload(blob)
+      {
+        id:           blob.id,
+        signed_id:    blob.signed_id,
+        filename:     blob.filename.to_s,
+        content_type: blob.content_type,
+        byte_size:    blob.byte_size,
+        created_at:   blob.created_at,
+        url:          ml_blob_url(blob),
+        thumb_url:    ml_thumb_url(blob)
+      }
+    end
+
+    # Permanent URL to the original file. Active Storage route helpers live on the
+    # host app, so they are reached through the `main_app` proxy. With
+    # url_type = :proxy the URL streams through Rails (works for private buckets
+    # and external crawlers); the default :redirect 302s to the storage URL.
+    def ml_blob_url(blob)
+      if VenusMediaLibrary.configuration.url_type == :proxy
+        main_app.rails_storage_proxy_url(blob)
+      else
+        main_app.rails_blob_url(blob)
+      end
+    rescue StandardError
+      main_app.rails_blob_path(blob)
+    end
+
+    # Small variant used for the grid thumbnail. Falls back to the original URL
+    # when the blob can't be variated (e.g. SVG).
+    def ml_thumb_url(blob)
+      if blob.variable?
+        w, h = VenusMediaLibrary.configuration.thumbnail_size
+        main_app.rails_representation_url(blob.variant(resize_to_limit: [ w, h ]))
+      else
+        ml_blob_url(blob)
+      end
+    rescue StandardError
+      ml_blob_url(blob)
+    end
+  end
+end

data/app/helpers/venus_media_library/picker_helper.rb

@@ -0,0 +1,144 @@
+module VenusMediaLibrary
+  # Host-facing helper. Included into the host app's views by the engine (see
+  # VenusMediaLibrary::Engine), so apps can drop the picker next to any URL field.
+  #
+  #   <%= form_with model: @page do |f| %>
+  #     <%= media_picker_field f, :og_image %>
+  #   <% end %>
+  #
+  # Renders a text input (the field the host already had) plus a "Choose from
+  # library" button wired to open the modal. Selecting an image writes its URL
+  # into the input; a hidden `<field>_signed_id` input also receives the blob's
+  # signed id so the host can attach it if desired.
+  module PickerHelper
+    # form  - a form builder (form_with / form_for)
+    # field - the attribute holding the image URL (e.g. :og_image)
+    # opts:
+    #   :label            - button label (default "Choose from library")
+    #   :placeholder      - text input placeholder
+    #   :signed_id_field  - name for the hidden signed-id input
+    #                       (default "<field>_signed_id"); pass false to skip
+    #   :input_html       - extra HTML options merged into the text input
+    #   :class            - wrapper CSS class
+    def media_picker_field(form, field, **opts)
+      input_id  = "#{form.object_name}_#{field}".parameterize.tr("-", "_")
+      label     = opts.fetch(:label, "Choose from library")
+      wrapper   = opts.fetch(:class, "ml-field")
+      input_html = {
+        id:    input_id,
+        class: "ml-field__input",
+        placeholder: opts[:placeholder]
+      }.merge(opts[:input_html] || {})
+
+      signed_id_field = opts.fetch(:signed_id_field, "#{field}_signed_id")
+
+      # Endpoint the JS uses to load the picker frame for this field.
+      picker_src = venus_media_library.picker_path(target: input_id)
+
+      content_tag(:div, class: wrapper, data: { ml_field: input_id }) do
+        parts = []
+        parts << form.text_field(field, input_html)
+
+        if signed_id_field
+          hidden_id = "#{input_id}_signed_id"
+          parts << form.hidden_field(signed_id_field, id: hidden_id, data: { ml_signed_id_for: input_id })
+        end
+
+        parts << button_tag(label,
+          type: "button",
+          class: "ml-btn ml-btn--primary ml-field__button",
+          data: { ml_open: true, ml_target: input_id, ml_src: picker_src })
+
+        safe_join(parts)
+      end + venus_media_library_modal_shell
+    end
+
+    # Attach-mode picker. Use this for an Active Storage attachment (has_one_attached)
+    # rather than a URL column: the picker writes the chosen blob's signed_id into a
+    # hidden field NAMED FOR THE ATTACHMENT (e.g. product[cover]), so Rails attaches
+    # that blob on save.
+    #
+    #   <%= form_with model: @product do |f| %>
+    #     <%= media_attach_field f, :cover %>
+    #   <% end %>
+    #
+    # The visible input is a read-only preview (it is NOT submitted). The hidden
+    # attachment field is `disabled` until an image is picked, because submitting an
+    # empty string for a has_one_attached would DETACH the current file; the JS sets
+    # the signed_id and enables the field on selection.
+    #
+    # form       - a form builder bound to the record
+    # attachment - the has_one_attached name (e.g. :cover)
+    # opts:
+    #   :label       - button label (default "Choose from library")
+    #   :placeholder - preview input placeholder
+    #   :input_html  - extra HTML options merged into the preview input
+    #   :class       - wrapper CSS class
+    def media_attach_field(form, attachment, **opts)
+      input_id = "#{form.object_name}_#{attachment}".parameterize.tr("-", "_")
+      label    = opts.fetch(:label, "Choose from library")
+      wrapper  = opts.fetch(:class, "ml-field")
+
+      preview_html = {
+        id:    input_id,
+        class: "ml-field__input",
+        type:  "text",
+        readonly: true,
+        value: ml_attachment_preview_value(form.object, attachment),
+        placeholder: opts[:placeholder]
+      }.merge(opts[:input_html] || {})
+
+      picker_src = venus_media_library.picker_path(target: input_id)
+
+      content_tag(:div, class: wrapper, data: { ml_field: input_id }) do
+        parts = []
+
+        # Read-only preview of the current/chosen image. No name -> not submitted.
+        parts << tag.input(**preview_html)
+
+        # Hidden field named for the attachment. Disabled (so a blank value can't
+        # detach on save) until the JS writes a signed_id and enables it.
+        parts << form.hidden_field(attachment,
+          value: "",
+          disabled: true,
+          id: "#{input_id}_signed_id",
+          data: { ml_signed_id_for: input_id })
+
+        parts << button_tag(label,
+          type: "button",
+          class: "ml-btn ml-btn--primary ml-field__button",
+          data: { ml_open: true, ml_target: input_id, ml_src: picker_src })
+
+        safe_join(parts)
+      end + venus_media_library_modal_shell
+    end
+
+    # Best-effort URL for the currently attached file, used to seed the preview.
+    # Rescues to the filename (or blank) so a missing host/route never breaks the form.
+    def ml_attachment_preview_value(record, attachment)
+      attached = record.respond_to?(attachment) && record.public_send(attachment)
+      return "" unless attached && attached.respond_to?(:attached?) && attached.attached?
+
+      if VenusMediaLibrary.configuration.url_type == :proxy
+        rails_storage_proxy_url(attached)
+      else
+        rails_blob_url(attached)
+      end
+    rescue StandardError
+      begin
+        attached && attached.attached? ? attached.filename.to_s : ""
+      rescue StandardError
+        ""
+      end
+    end
+
+    # Renders the shared modal shell once per page. The picker frame is lazy
+    # loaded into it when a button is clicked.
+    def venus_media_library_modal_shell
+      return "".html_safe if @_venus_media_library_modal_rendered
+
+      @_venus_media_library_modal_rendered = true
+      render partial: "venus_media_library/pickers/modal"
+    end
+  end
+end

data/app/jobs/venus_media_library/application_job.rb

@@ -0,0 +1,4 @@
+module VenusMediaLibrary
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/venus_media_library/application_mailer.rb

@@ -0,0 +1,6 @@
+module VenusMediaLibrary
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/venus_media_library/application_record.rb

@@ -0,0 +1,5 @@
+module VenusMediaLibrary
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/views/layouts/venus_media_library/application.html.erb

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Media library</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= yield :head %>
+
+  <%= stylesheet_link_tag    "venus_media_library/application", media: "all" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/app/views/venus_media_library/images/_image.html.erb

@@ -0,0 +1,10 @@
+<%# Renders one selectable image tile. `image` is a payload hash from the controller. %>
+<button type="button"
+        class="ml-tile"
+        data-ml-signed-id="<%= image[:signed_id] %>"
+        data-ml-url="<%= image[:url] %>"
+        data-ml-filename="<%= image[:filename] %>"
+        title="<%= image[:filename] %>">
+  <img src="<%= image[:thumb_url] %>" alt="<%= image[:filename] %>" loading="lazy">
+  <span class="ml-tile__name"><%= image[:filename] %></span>
+</button>

data/app/views/venus_media_library/images/index.html.erb

@@ -0,0 +1,23 @@
+<div class="ml-library">
+  <header class="ml-library__header">
+    <h1>Media Library</h1>
+    <p class="ml-library__count"><%= @total_count %> image<%= "s" unless @total_count == 1 %></p>
+  </header>
+
+  <% if @images.empty? %>
+    <p class="ml-empty">No images yet. Upload one to get started.</p>
+  <% else %>
+    <div class="ml-grid" data-ml-grid>
+      <%= render partial: "venus_media_library/images/image", collection: @images, as: :image %>
+    </div>
+  <% end %>
+
+  <nav class="ml-pagination">
+    <% if @page > 1 %>
+      <%= link_to "← Newer", images_path(page: @page - 1), class: "ml-btn" %>
+    <% end %>
+    <% if @has_more %>
+      <%= link_to "Older →", images_path(page: @page + 1), class: "ml-btn" %>
+    <% end %>
+  </nav>
+</div>

data/app/views/venus_media_library/pickers/_modal.html.erb

@@ -0,0 +1,16 @@
+<%# Shared modal shell. Rendered once per page by media_picker_field. The picker
+    Turbo Frame is loaded into #venus_media_library_picker on open. %>
+<div id="ml-modal" class="ml-modal" hidden aria-hidden="true" role="dialog" aria-modal="true" aria-label="Media Library">
+  <div class="ml-modal__backdrop" data-ml-close></div>
+  <div class="ml-modal__dialog">
+    <div class="ml-modal__header">
+      <h2 class="ml-modal__title">Media Library</h2>
+      <button type="button" class="ml-modal__close" data-ml-close aria-label="Close">&times;</button>
+    </div>
+    <div class="ml-modal__body">
+      <turbo-frame id="venus_media_library_picker">
+        <p class="ml-empty">Loading…</p>
+      </turbo-frame>
+    </div>
+  </div>
+</div>

data/app/views/venus_media_library/pickers/_picker.html.erb

@@ -0,0 +1,27 @@
+<%# Picker body loaded into the modal as a Turbo Frame. `target` is the id of the
+    host input to receive the chosen image. %>
+<turbo-frame id="venus_media_library_picker" class="ml-picker" data-ml-target="<%= target %>">
+  <div class="ml-picker__toolbar">
+    <label class="ml-btn ml-btn--primary">
+      Upload image
+      <input type="file" accept="image/*" hidden data-ml-upload>
+    </label>
+    <span class="ml-picker__hint" data-ml-status></span>
+  </div>
+
+  <% if images.empty? %>
+    <p class="ml-empty">No images yet. Upload one above.</p>
+  <% else %>
+    <div class="ml-grid" data-ml-grid>
+      <%= render partial: "venus_media_library/images/image", collection: images, as: :image %>
+    </div>
+  <% end %>
+
+  <% if has_more %>
+    <div class="ml-picker__more">
+      <a href="<%= picker_path(target: target, page: page + 1) %>"
+         data-turbo-frame="venus_media_library_picker"
+         class="ml-btn">Load older</a>
+    </div>
+  <% end %>
+</turbo-frame>

data/config/routes.rb

@@ -0,0 +1,9 @@
+VenusMediaLibrary::Engine.routes.draw do
+  # Image library: index lists images (HTML grid + JSON), create handles uploads.
+  resources :images, only: [ :index, :create ]
+
+  # Turbo Frame that renders the picker modal body for a given target field.
+  get "picker", to: "pickers#show", as: :picker
+
+  root to: "images#index"
+end

data/lib/tasks/venus_media_library_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :venus_media_library do
+#   # Task goes here
+# end

data/lib/venus_media_library/engine.rb

@@ -0,0 +1,25 @@
+module VenusMediaLibrary
+  class Engine < ::Rails::Engine
+    isolate_namespace VenusMediaLibrary
+
+    # Make the host-facing picker helper available in the host app's views so
+    # apps can call `media_picker_field` without any manual include.
+    initializer "venus_media_library.host_helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include VenusMediaLibrary::PickerHelper
+      end
+    end
+
+    # Ensure the engine's JS is discoverable by Propshaft/Sprockets in the host.
+    initializer "venus_media_library.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.paths << root.join("app/assets/javascripts")
+        app.config.assets.precompile += %w[venus_media_library/venus_media_library.js]
+      end
+    end
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+  end
+end

data/lib/venus_media_library/version.rb

@@ -0,0 +1,3 @@
+module VenusMediaLibrary
+  VERSION = "0.1.0"
+end

data/lib/venus_media_library.rb

@@ -0,0 +1,73 @@
+require "venus_media_library/version"
+require "venus_media_library/engine"
+
+module VenusMediaLibrary
+  # Host apps configure the engine through `VenusMediaLibrary.configure`:
+  #
+  #   VenusMediaLibrary.configure do |config|
+  #     config.allowed_content_types = %w[image/png image/jpeg image/webp]
+  #     config.thumbnail_size        = [ 300, 300 ]
+  #     config.per_page              = 40
+  #     config.storage_service       = :amazon
+  #   end
+  class Configuration
+    # Content types accepted by the uploader and shown in the library grid.
+    # Every entry is matched literally; the index additionally shows any blob
+    # whose content_type starts with "image/".
+    attr_accessor :allowed_content_types
+
+    # [width, height] used for the grid thumbnail variant.
+    attr_accessor :thumbnail_size
+
+    # Number of images per page in the index.
+    attr_accessor :per_page
+
+    # Optional Active Storage service name to attach uploads to. When nil the
+    # host app's default service (`config.active_storage.service`) is used, so
+    # the engine stays storage-agnostic (Disk in dev, S3 in prod, etc.).
+    attr_accessor :storage_service
+
+    # How image URLs in the payload/picker are built:
+    #   :redirect (default) -> rails_blob_url          (302s to the storage URL)
+    #   :proxy              -> rails_storage_proxy_url  (Rails streams the bytes)
+    # Use :proxy when the bucket is private and images must be publicly fetchable
+    # by external crawlers (e.g. an og:image on a private S3 bucket in proxy mode).
+    # Still storage-agnostic: both are Active Storage route helpers.
+    attr_accessor :url_type
+
+    # Optional access gate. A proc run in the engine controller's context before
+    # every action (via instance_exec), so it can call host helpers like
+    # `current_user`, `redirect_to`, or `head`. Left nil the engine is open; the
+    # host sets this to restrict the picker/upload endpoints to admins.
+    #
+    #   VenusMediaLibrary.configure do |c|
+    #     c.authenticate_with = -> { redirect_to main_app.root_path unless current_user&.admin? }
+    #   end
+    attr_accessor :authenticate_with
+
+    def initialize
+      @allowed_content_types = %w[image/png image/jpeg image/jpg image/gif image/webp image/svg+xml]
+      @thumbnail_size        = [ 300, 300 ]
+      @per_page              = 40
+      @storage_service       = nil
+      @url_type              = :redirect
+      @authenticate_with     = nil
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+      configuration
+    end
+
+    # Test/host reset hook.
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: venus_media_library
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Good Works On Earth
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: image_processing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+description: |-
+  Media Library is a mountable Rails engine that lists images stored in Active Storage
+  (S3, Google Cloud Storage, Disk — whatever the host app configures) and gives content
+  editors a modal image picker. Drop `media_picker_field` next to any URL field (such as
+  an og:image field) so editors can select an existing image or upload a new one instead
+  of typing a path. Storage-agnostic, namespaced, and publishable.
+email:
+- hello@goodworksonearth.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/javascripts/venus_media_library/venus_media_library.js
+- app/assets/stylesheets/venus_media_library/application.css
+- app/assets/stylesheets/venus_media_library/picker.css
+- app/controllers/venus_media_library/application_controller.rb
+- app/controllers/venus_media_library/images_controller.rb
+- app/controllers/venus_media_library/pickers_controller.rb
+- app/helpers/venus_media_library/application_helper.rb
+- app/helpers/venus_media_library/images_helper.rb
+- app/helpers/venus_media_library/picker_helper.rb
+- app/jobs/venus_media_library/application_job.rb
+- app/mailers/venus_media_library/application_mailer.rb
+- app/models/venus_media_library/application_record.rb
+- app/views/layouts/venus_media_library/application.html.erb
+- app/views/venus_media_library/images/_image.html.erb
+- app/views/venus_media_library/images/index.html.erb
+- app/views/venus_media_library/pickers/_modal.html.erb
+- app/views/venus_media_library/pickers/_picker.html.erb
+- config/routes.rb
+- lib/tasks/venus_media_library_tasks.rake
+- lib/venus_media_library.rb
+- lib/venus_media_library/engine.rb
+- lib/venus_media_library/version.rb
+homepage: https://github.com/goodworksonearth/venus_media_library
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/goodworksonearth/venus_media_library
+  changelog_uri: https://github.com/goodworksonearth/venus_media_library/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/goodworksonearth/venus_media_library/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A mountable Rails engine that turns Active Storage into a browsable media
+  library with an image picker.
+test_files: []