activeblob 0.1.0

data/app/models/activeblob/blob.rb

@@ -0,0 +1,122 @@
+module ActiveBlob
+  class Blob < ActiveRecord::Base
+    self.table_name = 'blobs'
+
+    include ActiveBlob::BlobHelpers
+
+    attr_reader :data
+
+    has_many :attachments, class_name: 'ActiveBlob::Attachment', dependent: :destroy
+    validates :file, presence: true, on: :create
+    validates :url, format: { with: URI::regexp(%w(http https)) }, on: :create, if: ->(b) { b.url }
+    validates :content_type, presence: true
+    validates :sha1, presence: true, length: { is: 20 }
+    validates :size, numericality: { only_integer: true, greater_than: 0 }
+
+    after_save    :store_file
+    after_destroy :delete_file
+
+    def self.new(attrs={})
+      if attrs[:url] && attrs[:url] =~ URI::regexp(%w(http https))
+        attrs[:file] = download_url(attrs.delete(:url))
+      end
+
+      if attrs[:base64]
+        attrs[:file] = base64_file(attrs.delete(:base64), attrs)
+      end
+
+      if attrs[:data]
+        attrs[:file] = data_file(attrs.delete(:data), attrs)
+      end
+
+      if attrs[:file]
+        klass = attrs[:content_type] ? content_type_class(attrs[:content_type]) : file_class(attrs[:file])
+        sha1 = file_sha1(attrs[:file])
+        klass.find_by_sha1(sha1) || (klass == self ? super(attrs) : klass.new(attrs))
+      else
+        super(attrs)
+      end
+    end
+
+    def url=(value)
+      @url = value if !persisted?
+    end
+
+    def url(**options)
+      options[:disposition] = options[:disposition] == 'inline' ? 'inline' : 'attachment'
+      if options[:filename]
+        options[:disposition] += "; filename=\"#{URI.encode_www_form_component(options[:filename].force_encoding(Encoding::UTF_8)).gsub("%2F", "/")}\""
+      end
+
+      if persisted?
+        if self.class.storage.local?
+          self.class.storage.url(id)
+        else
+          self.class.storage.url(id, **options.slice(:disposition, :expires_in))
+        end
+      else
+        @url
+      end
+    end
+
+    def file
+      @queued
+    end
+
+    def data=(value)
+      raise 'Cannot set file on persisted blob or blob with file already set' if persisted? || @file
+      self.size = value.bytesize
+      self.sha1 = Digest::SHA1.digest(value)
+
+      @queued = Tempfile.new(binmode: true)
+      @queued.write(value)
+      @queued.flush
+      @queued.rewind
+    end
+
+    def extension
+      "." + MiniMime.lookup_by_content_type(content_type).extension
+    end
+
+    def file=(file)
+      raise 'Cannot set file on persisted blob or blob with file already set' if persisted? || @file
+      return if file.nil?
+
+      if self.content_type.nil? || self.content_type == 'application/octet-stream'
+        self.content_type = file_content_type(file)
+      end
+      self.size = file.size
+      self.sha1 = file_sha1(file)
+
+      @queued = Tempfile.new(binmode: true)
+      FileUtils.cp(file.path, @queued.path)
+    end
+
+    def open(basename: nil, &block)
+      basename ||= ['', extension]
+      self.class.storage.copy_to_tempfile(id, basename: basename, &block)
+    end
+
+    private
+
+    def store_file
+      if @queued
+        self.class.storage.write(id, @queued, { content_type: content_type })
+      end
+    ensure
+      if @queued
+        @queued.close
+        if @queued.is_a? ActionDispatch::Http::UploadedFile
+          @queued.tempfile.unlink
+        else
+          @queued.unlink
+        end
+        @queued = nil
+      end
+    end
+
+    def delete_file
+      self.class.storage.delete(id)
+    end
+  end
+end

data/lib/activeblob/blob_helpers.rb

@@ -0,0 +1,166 @@
+require 'active_support/concern'
+require 'mini_mime'
+require 'digest/sha1'
+require 'base64'
+require 'tempfile'
+require 'net/http'
+require 'uri'
+
+module ActiveBlob
+  module BlobHelpers
+    extend ActiveSupport::Concern
+
+    def file_content_type(file)
+      self.class.file_content_type(file)
+    end
+
+    def file_sha1(file)
+      self.class.file_sha1(file)
+    end
+
+    def self.filename_from_file(file)
+      fn = if file.respond_to?(:original_filename)
+        file.original_filename || File.basename(file.path)
+      else
+        File.basename(file.path)
+      end
+      "#{File.basename(fn, File.extname(fn))}#{File.extname(fn)&.downcase}"
+    end
+
+    class_methods do
+      def storage
+        ActiveBlob.storage
+      end
+
+      def file_sha1(file)
+        if file.is_a?(ActionDispatch::Http::UploadedFile)
+          if file.instance_variable_get(:@sha1)
+            file.instance_variable_get(:@sha1)
+          else
+            digest = Digest::SHA1.file(file.path).digest
+            file.instance_variable_set(:@sha1, digest)
+            digest
+          end
+        else
+          Digest::SHA1.file(file.path).digest
+        end
+      end
+
+      def download_url(url, headers: {})
+        return unless url =~ URI::regexp(%w(http https))
+        uri = URI.parse(url)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+
+        http.request_get(uri.request_uri, headers) do |resp|
+          if resp.is_a?(Net::HTTPRedirection)
+            return download_url(resp['location'])
+          elsif resp.is_a?(Net::HTTPSuccess)
+            tmpfile = Tempfile.new(binmode: true)
+            digest = Digest::SHA1.new
+
+            resp.read_body do |part|
+              digest << part
+              tmpfile.write(part)
+            end
+            tmpfile.flush
+            tmpfile.rewind
+
+            filename = if resp["content-disposition"] && resp["content_disposition"] =~ /filename=/
+              File.basename(resp["content-disposition"].match(/filename=\"(.*)\"/)[1])
+            else
+              fn = File.basename(uri.path)
+              fn = 'index' if fn == '/'
+              mime_type = MiniMime.lookup_by_content_type(resp["content-type"])
+              extension = (mime_type ? ".#{mime_type.extension}" : File.extname(fn))
+              File.basename(uri.path, ".*") + extension
+            end
+
+            content_type = resp["content-type"]
+            if !content_type.present?
+              # Fallback to MiniMime if content-type header is missing
+              content_type = MiniMime.lookup_by_filename(filename)&.content_type || 'application/octet-stream'
+            end
+
+            file = ActionDispatch::Http::UploadedFile.new({
+              filename: filename,
+              type: content_type,
+              tempfile: tmpfile
+            })
+            file.instance_variable_set(:@sha1, digest.digest)
+            return file
+          else
+            raise Net::HTTPError.new("HTTP #{resp.code} loading #{url}", resp)
+          end
+        end
+      end
+
+      def data_file(value, attrs = {})
+        sha1 = Digest::SHA1.digest(value)
+        tmpfile = Tempfile.new(binmode: true)
+        tmpfile.write(value)
+        tmpfile.flush
+        tmpfile.rewind
+
+        file = ActionDispatch::Http::UploadedFile.new({
+          filename: attrs[:filename],
+          type: attrs[:content_type],
+          tempfile: tmpfile
+        })
+        file.instance_variable_set(:@sha1, sha1)
+        file
+      end
+
+      def base64_file(value, attrs = {})
+        value = Base64.decode64(value)
+        sha1 = Digest::SHA1.digest(value)
+        tmpfile = Tempfile.new(binmode: true)
+        tmpfile.write(value)
+        tmpfile.flush
+        tmpfile.rewind
+
+        file = ActionDispatch::Http::UploadedFile.new({
+          filename: attrs[:filename],
+          type: attrs[:content_type],
+          tempfile: tmpfile
+        })
+        file.instance_variable_set(:@sha1, sha1)
+        file
+      end
+
+      def file_content_type(file)
+        content_type = if file.respond_to?(:content_type)
+          file.content_type&.strip
+        else
+          'application/octet-stream'
+        end
+
+        if content_type == 'application/octet-stream'
+          content_type = MiniMime.lookup_by_filename(file.path)&.content_type
+        end
+
+        content_type
+      end
+
+      def file_class(file)
+        content_type_class(file_content_type(file))
+      end
+
+      def content_type_class(content_type)
+        descendant = self.descendants.find do |descendant|
+          descendant.validators_on(:content_type).find do |validator|
+            case validator
+            when ActiveModel::Validations::FormatValidator
+              content_type =~ validator.options[:with]
+            when ActiveModel::Validations::InclusionValidator
+              validator.send(:delimiter).include?(content_type)
+            end
+          end
+        end
+
+        descendant || self
+      end
+    end
+  end
+end

data/lib/activeblob/engine.rb

@@ -0,0 +1,20 @@
+require "rails"
+
+module ActiveBlob
+  class Engine < ::Rails::Engine
+    isolate_namespace ActiveBlob
+
+    config.autoload_paths << File.expand_path('../../app/models', __dir__)
+
+    config.generators do |g|
+      g.test_framework :test_unit, fixture: false
+    end
+
+    initializer "activeblob.active_record", before: :load_config_initializers do
+      ActiveSupport.on_load(:active_record) do
+        require "activeblob/model_extensions"
+        ActiveRecord::Base.include(ActiveBlob::ModelExtensions)
+      end
+    end
+  end
+end

data/lib/activeblob/model_extensions.rb

@@ -0,0 +1,114 @@
+module ActiveBlob
+  module ModelExtensions
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def has_one_blob(name, dependent: :destroy)
+        has_one :"#{name}", -> { where(type: name) }, class_name: "::ActiveBlob::Attachment", as: :record, inverse_of: :record, dependent: dependent
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{name}_attributes=(attrs)
+            attachment = if self.#{name} && self.#{name}.id == (attrs[:id] || attrs['id'])
+              self.#{name}
+            end
+
+            if attachment
+              attachment.order = 0
+              attachment.filename = (attrs[:filename] || attrs['filename']) if (attrs[:filename] || attrs['filename'])
+              attachment.blob_id = (attrs[:blob_id] || attrs['blob_id']) if (attrs[:blob_id] || attrs['blob_id'])
+            else
+              attachment = ActiveBlob::Attachment.new({
+                order: 0,
+                filename: (attrs[:filename] || attrs['filename']),
+                blob_id: (attrs[:blob_id] || attrs['blob_id']),
+                type: '#{name}'
+              })
+            end
+
+            self.#{name} = attachment
+          end
+
+          def #{name}=(file)
+            if file && !file.is_a?(ActiveBlob::Attachment)
+              file = ActiveBlob::Attachment.new({
+                blob: file,
+                filename: ActiveBlob::BlobHelpers.filename_from_file(file),
+                type: '#{name}'
+              })
+            elsif file
+              file.type = '#{name}'
+            end
+            association(:#{name}).writer(file)
+          end
+        RUBY
+      end
+
+      def has_many_blobs(name, **options)
+        options[:dependent] ||= :destroy
+        options = {
+          dependent: :destroy,
+          autosave: true,
+          inverse_of: :record,
+          as: :record,
+          class_name: '::ActiveBlob::Attachment'
+        }.merge(options)
+        singular = name.to_s.singularize
+        has_many :"#{name}", -> { where(type: singular).order(order: :asc) }, **options
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{name}_attributes=(attributes)
+            if !attributes.is_a?(Array)
+              raise ArgumentError, "Array expected for attributes `#{name}`, got \#{attributes.class.name} (\#{attributes.inspect})"
+            end
+
+            attachments = attributes.map.with_index do |attrs, i|
+              attachment = self.#{name}.find { |a| a.id == (attrs[:id] || attrs['id']) }
+
+              if attachment
+                attachment.order = i
+                attachment.filename = (attrs[:filename] || attrs['filename']) if (attrs[:filename] || attrs['filename'])
+                attachment.blob_id = (attrs[:blob_id] || attrs['blob_id']) if (attrs[:blob_id] || attrs['blob_id'])
+                attachment
+              else
+                ActiveBlob::Attachment.new({
+                  order: i,
+                  filename: (attrs[:filename] || attrs['filename']),
+                  blob_id: (attrs[:blob_id] || attrs['blob_id']),
+                  type: '#{singular}'
+                })
+              end
+            end
+
+            self.#{name} = attachments
+          end
+
+          def #{name}=(files)
+            files = files.map.with_index do |file, i|
+              if file.is_a?(ActiveBlob::Attachment)
+                file.type = '#{singular}'
+                file.order = i
+                file
+              elsif file.is_a?(ActiveBlob::Blob)
+                ActiveBlob::Attachment.new({
+                  order: i,
+                  type: '#{singular}',
+                  blob: file,
+                  filename: ActiveBlob::BlobHelpers.filename_from_file(file)
+                })
+              else
+                ActiveBlob::Attachment.new({
+                  order: i,
+                  type: '#{singular}',
+                  blob: ActiveBlob::Blob.new(file: file),
+                  filename: ActiveBlob::BlobHelpers.filename_from_file(file)
+                })
+              end
+            end
+
+            association(:#{name}).writer(files)
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/activeblob/storage/filesystem.rb

@@ -0,0 +1,60 @@
+require 'fileutils'
+
+module ActiveBlob
+  module Storage
+    class Filesystem
+      attr_reader :path
+
+      def initialize(config = {})
+        @path = config[:path] || Rails.root.join('storage', 'blobs')
+        FileUtils.mkdir_p(@path)
+      end
+
+      def local?
+        true
+      end
+
+      def write(id, file, options = {})
+        file_path = path_for(id)
+        FileUtils.mkdir_p(File.dirname(file_path))
+        FileUtils.cp(file.path, file_path)
+      end
+
+      def read(id)
+        File.read(path_for(id))
+      end
+
+      def delete(id)
+        FileUtils.rm_f(path_for(id))
+      end
+
+      def exists?(id)
+        File.exist?(path_for(id))
+      end
+
+      def url(id, **options)
+        "/blobs/#{id}/download"
+      end
+
+      def copy_to_tempfile(id, basename: nil, &block)
+        basename ||= ['blob', '']
+        source_path = path_for(id)
+
+        Tempfile.create(basename, binmode: true) do |tmpfile|
+          FileUtils.cp(source_path, tmpfile.path)
+          tmpfile.rewind
+          block.call(tmpfile)
+        end
+      end
+
+      private
+
+      def path_for(id)
+        # Split ID into subdirectories for better filesystem performance
+        # e.g., "abc123" -> "ab/c1/abc123"
+        id_str = id.to_s
+        File.join(@path, id_str[0..1], id_str[2..3], id_str)
+      end
+    end
+  end
+end

data/lib/activeblob/storage/s3.rb

@@ -0,0 +1,68 @@
+require 'aws-sdk-s3'
+
+module ActiveBlob
+  module Storage
+    class S3
+      attr_reader :bucket, :client
+
+      def initialize(config = {})
+        @bucket = config[:bucket]
+        @client = Aws::S3::Client.new(
+          access_key_id: config[:access_key_id],
+          secret_access_key: config[:secret_access_key],
+          region: config[:region] || 'us-east-1',
+          endpoint: config[:endpoint]
+        )
+        @resource = Aws::S3::Resource.new(client: @client)
+        @bucket_obj = @resource.bucket(@bucket)
+      end
+
+      def local?
+        false
+      end
+
+      def write(id, file, options = {})
+        @bucket_obj.object(key_for(id)).upload_file(
+          file.path,
+          content_type: options[:content_type]
+        )
+      end
+
+      def read(id)
+        @bucket_obj.object(key_for(id)).get.body.read
+      end
+
+      def delete(id)
+        @bucket_obj.object(key_for(id)).delete
+      end
+
+      def exists?(id)
+        @bucket_obj.object(key_for(id)).exists?
+      end
+
+      def url(id, disposition: 'attachment', expires_in: 300)
+        @bucket_obj.object(key_for(id)).presigned_url(
+          :get,
+          expires_in: expires_in,
+          response_content_disposition: disposition
+        )
+      end
+
+      def copy_to_tempfile(id, basename: nil, &block)
+        basename ||= ['blob', '']
+
+        Tempfile.create(basename, binmode: true) do |tmpfile|
+          @bucket_obj.object(key_for(id)).get(response_target: tmpfile.path)
+          tmpfile.rewind
+          block.call(tmpfile)
+        end
+      end
+
+      private
+
+      def key_for(id)
+        "blobs/#{id}"
+      end
+    end
+  end
+end

data/lib/activeblob/version.rb

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

data/lib/activeblob.rb

@@ -0,0 +1,46 @@
+require "activeblob/version"
+require "activeblob/engine"
+require "activeblob/blob_helpers"
+require "activeblob/storage/filesystem"
+require "activeblob/storage/s3"
+require "activeblob/model_extensions"
+
+# Require models explicitly since they're in a gem
+require_relative "../app/models/activeblob/blob"
+require_relative "../app/models/activeblob/attachment"
+require_relative "../app/models/activeblob/blob/image"
+require_relative "../app/models/activeblob/blob/video"
+require_relative "../app/models/activeblob/blob/pdf"
+
+module ActiveBlob
+  mattr_accessor :storage_config
+
+  class << self
+    def configure
+      yield self if block_given?
+    end
+
+    def storage
+      @storage ||= begin
+        config = storage_config || default_storage_config
+        case config[:storage]
+        when 'filesystem', nil
+          ActiveBlob::Storage::Filesystem.new(config)
+        when 's3'
+          ActiveBlob::Storage::S3.new(config)
+        else
+          raise "Unknown storage type: #{config[:storage]}"
+        end
+      end
+    end
+
+    private
+
+    def default_storage_config
+      {
+        storage: 'filesystem',
+        path: Rails.root.join('storage', 'blobs')
+      }
+    end
+  end
+end

data/lib/generators/activeblob/install/install_generator.rb

@@ -0,0 +1,30 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Activeblob
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path('templates', __dir__)
+
+      def self.next_migration_number(path)
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+
+      def copy_migrations
+        migration_template "create_blobs.rb", "db/migrate/create_blobs.rb"
+        sleep 1 # Ensure unique timestamp
+        migration_template "create_attachments.rb", "db/migrate/create_attachments.rb"
+      end
+
+      def create_initializer
+        template "initializer.rb", "config/initializers/activeblob.rb"
+      end
+
+      def show_readme
+        readme "README" if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/activeblob/install/templates/README

@@ -0,0 +1,41 @@
+===============================================================================
+
+ActiveBlob has been installed!
+
+Next steps:
+
+1. Run the migrations:
+   rails db:migrate
+
+2. Configure your storage backend in config/initializers/activeblob.rb
+
+3. Add blob attachments to your models:
+
+   # Single attachment
+   class User < ApplicationRecord
+     has_one_blob :avatar
+   end
+
+   # Multiple attachments
+   class Post < ApplicationRecord
+     has_many_blobs :images
+   end
+
+4. Use in your application:
+
+   # Create with file upload
+   user.avatar = params[:avatar]
+
+   # Create with URL
+   blob = ActiveBlob::Blob.new(url: "https://example.com/image.jpg")
+
+   # Create with base64
+   blob = ActiveBlob::Blob.new(base64: base64_string, content_type: "image/png")
+
+   # Get URL
+   user.avatar.url
+   blob.url(disposition: 'inline', filename: 'custom.jpg')
+
+For more information, visit: https://github.com/bemky/activeblob
+
+===============================================================================

data/lib/generators/activeblob/install/templates/create_attachments.rb

@@ -0,0 +1,20 @@
+class CreateAttachments < ActiveRecord::Migration[6.1]
+  def change
+    create_table :attachments, id: :uuid do |t|
+      t.string :type
+      t.integer :order, null: false, default: 0
+      t.string :filename
+      t.string :record_type
+      t.uuid :record_id
+      t.uuid :blob_id, null: false
+
+      t.timestamps
+    end
+
+    add_index :attachments, [:record_type, :record_id]
+    add_index :attachments, :blob_id
+    add_index :attachments, [:blob_id, :record_id, :record_type, :type, :filename],
+              unique: true,
+              name: 'index_attachments_on_blob_record_type_filename'
+  end
+end