file_blobs_rails 0.1.0

data/file_blobs_rails.gemspec

@@ -0,0 +1,131 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: file_blobs_rails 0.1.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "file_blobs_rails"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Victor Costan"]
+  s.date = "2016-10-31"
+  s.description = "This gem is a quick way to add database-backed file storage to a Rails application. Files are stored in a dedicated table and de-duplicated."
+  s.email = "victor@costan.us"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".travis.yml",
+    "Gemfile",
+    "Gemfile.lock",
+    "Gemfile.rails5",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "file_blobs_rails.gemspec",
+    "lib/file_blobs_rails.rb",
+    "lib/file_blobs_rails/action_controller_data_streaming_extensions.rb",
+    "lib/file_blobs_rails/active_record_extensions.rb",
+    "lib/file_blobs_rails/active_record_fixture_set_extensions.rb",
+    "lib/file_blobs_rails/active_record_migration_extensions.rb",
+    "lib/file_blobs_rails/active_record_table_definition_extensions.rb",
+    "lib/file_blobs_rails/active_support_test_extensions.rb",
+    "lib/file_blobs_rails/blob_model.rb",
+    "lib/file_blobs_rails/engine.rb",
+    "lib/file_blobs_rails/file_blob_proxy.rb",
+    "lib/file_blobs_rails/generators/blob_model_generator.rb",
+    "lib/file_blobs_rails/generators/blob_owner_generator.rb",
+    "lib/file_blobs_rails/generators/templates/001_create_file_blobs.rb.erb",
+    "lib/file_blobs_rails/generators/templates/002_create_blob_owners.rb.erb",
+    "lib/file_blobs_rails/generators/templates/blob_owner.rb.erb",
+    "lib/file_blobs_rails/generators/templates/blob_owner_test.rb.erb",
+    "lib/file_blobs_rails/generators/templates/blob_owners.yml.erb",
+    "lib/file_blobs_rails/generators/templates/file_blob.rb.erb",
+    "lib/file_blobs_rails/generators/templates/file_blob_test.rb.erb",
+    "lib/file_blobs_rails/generators/templates/file_blobs.yml.erb",
+    "lib/file_blobs_rails/generators/templates/files/invoice.pdf",
+    "lib/file_blobs_rails/generators/templates/files/ruby.png",
+    "test/blob_model_test.rb",
+    "test/blob_owner_test.rb",
+    "test/controller_extensions_test.rb",
+    "test/file_blob_proxy_test.rb",
+    "test/file_blob_test.rb",
+    "test/file_blobs_fixture_test.rb",
+    "test/fixtures/003_create_gem_test_blobs.rb",
+    "test/fixtures/004_create_gem_test_messages.rb",
+    "test/fixtures/files/invoice.pdf",
+    "test/fixtures/files/ruby.png",
+    "test/fixtures/gem_test_blob.rb",
+    "test/fixtures/gem_test_message.rb",
+    "test/garbage_collection_test.rb",
+    "test/helpers/action_controller.rb",
+    "test/helpers/db_setup.rb",
+    "test/helpers/fixtures.rb",
+    "test/helpers/i18n.rb",
+    "test/helpers/migrations.rb",
+    "test/helpers/rails.rb",
+    "test/helpers/routes.rb",
+    "test/helpers/test_order.rb",
+    "test/test_extensions_test.rb",
+    "test/test_helper.rb"
+  ]
+  s.homepage = "https://github.com/pwnall/file_blobs_rails"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.5.1"
+  s.summary = "Database-backed file storage for Rails 5 applications."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, [">= 5.0.0.1"])
+      s.add_development_dependency(%q<bundler>, [">= 1.6.6"])
+      s.add_development_dependency(%q<jeweler>, [">= 2.1.1"])
+      s.add_development_dependency(%q<mocha>, [">= 1.2.1"])
+      s.add_development_dependency(%q<mysql2>, [">= 0.4.4"])
+      s.add_development_dependency(%q<omniauth>, [">= 1.3.1"])
+      s.add_development_dependency(%q<pg>, [">= 0.19.0"])
+      s.add_development_dependency(%q<rake>, [">= 11.3.0"])
+      s.add_development_dependency(%q<sqlite3>, [">= 1.3.12"])
+      s.add_development_dependency(%q<yard>, [">= 0.9.5"])
+      s.add_development_dependency(%q<rubysl>, [">= 0"])
+      s.add_development_dependency(%q<rubysl-bundler>, [">= 0"])
+      s.add_development_dependency(%q<rubysl-rake>, [">= 0"])
+    else
+      s.add_dependency(%q<rails>, [">= 5.0.0.1"])
+      s.add_dependency(%q<bundler>, [">= 1.6.6"])
+      s.add_dependency(%q<jeweler>, [">= 2.1.1"])
+      s.add_dependency(%q<mocha>, [">= 1.2.1"])
+      s.add_dependency(%q<mysql2>, [">= 0.4.4"])
+      s.add_dependency(%q<omniauth>, [">= 1.3.1"])
+      s.add_dependency(%q<pg>, [">= 0.19.0"])
+      s.add_dependency(%q<rake>, [">= 11.3.0"])
+      s.add_dependency(%q<sqlite3>, [">= 1.3.12"])
+      s.add_dependency(%q<yard>, [">= 0.9.5"])
+      s.add_dependency(%q<rubysl>, [">= 0"])
+      s.add_dependency(%q<rubysl-bundler>, [">= 0"])
+      s.add_dependency(%q<rubysl-rake>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rails>, [">= 5.0.0.1"])
+    s.add_dependency(%q<bundler>, [">= 1.6.6"])
+    s.add_dependency(%q<jeweler>, [">= 2.1.1"])
+    s.add_dependency(%q<mocha>, [">= 1.2.1"])
+    s.add_dependency(%q<mysql2>, [">= 0.4.4"])
+    s.add_dependency(%q<omniauth>, [">= 1.3.1"])
+    s.add_dependency(%q<pg>, [">= 0.19.0"])
+    s.add_dependency(%q<rake>, [">= 11.3.0"])
+    s.add_dependency(%q<sqlite3>, [">= 1.3.12"])
+    s.add_dependency(%q<yard>, [">= 0.9.5"])
+    s.add_dependency(%q<rubysl>, [">= 0"])
+    s.add_dependency(%q<rubysl-bundler>, [">= 0"])
+    s.add_dependency(%q<rubysl-rake>, [">= 0"])
+  end
+end
+

data/lib/file_blobs_rails/action_controller_data_streaming_extensions.rb

@@ -0,0 +1,60 @@
+require 'action_controller'
+
+module FileBlobs
+
+# Module mixed into ActionController::DataStreaming.
+module ActionControllerDataStreamingExtensions
+  ETAG = 'ETag'.freeze
+  HTTP_IF_NONE_MATCH = 'HTTP_IF_NONE_MATCH'.freeze
+
+  # Sends a file blob to the browser.
+  #
+  # This method uses HTTP's strong etag feature to facilitate serving the files
+  # from a cache whenever possible.
+  #
+  # @param [FileBlobs::FileBlobProxy] proxy a proxy for a collection of
+  #     attributes generated by has_file_blob
+  # @param [Hash<Symbol, Object>] options tweaks the options passed to the
+  #     underlying send_data call; this method sets the  :filename and :type
+  #     options, but their values can be overridden by the options hash
+  # @see ActionController::DataStreaming#send_data
+  def send_file_blob(proxy, options = {})
+    if request.get_header(HTTP_IF_NONE_MATCH) == proxy.blob_id
+      head :not_modified
+    else
+      response.headers[ETAG] = proxy.blob_id
+      send_options = { type: proxy.mime_type, filename: proxy.original_name }
+      send_options.merge! options
+      send_data proxy.data, send_options
+    end
+  end
+
+  # Creates the table used to hold file blobs.
+  #
+  # @param [Symbol] table_name the name of the table used to hold file data
+  # @param [Hash<Symbol, Object>] options
+  # @option options [Boolean] null true
+  # @option options [Integer] blob_limit the maximum file size that can be
+  #     stored in the table; defaults to 1 megabyte
+  def file_blob(column_name_base = :file, options = {}, &block)
+    allow_null = options[:null] || false
+    mime_type_limit = options[:mime_type_limit] || 64
+    file_name_limit = options[:file_name_limit] || 256
+
+    # The index is needed for garbage-collection eligibility checks.
+    string :"#{column_name_base}_blob_id", limit: 48, null: allow_null,
+           index: true
+
+    integer :"#{column_name_base}_size", null: allow_null
+    string :"#{column_name_base}_mime_type", limit: mime_type_limit,
+           null: allow_null
+    string :"#{column_name_base}_original_name", limit: file_name_limit,
+           null: allow_null
+  end
+end  # module FileBlobs::ActionControllerDataStreamingExtensions
+
+end  # namespace FileBlobs
+
+ActionController::DataStreaming.class_eval do
+  include FileBlobs::ActionControllerDataStreamingExtensions
+end

data/lib/file_blobs_rails/active_record_extensions.rb

@@ -0,0 +1,257 @@
+require 'active_record'
+require 'active_support'
+
+module FileBlobs
+
+# Module mixed into ActiveRecord::Base.
+module ActiveRecordExtensions
+  extend ActiveSupport::Concern
+end  # module FileBlobs::ActiveRecordExtensions
+
+module ActiveRecordExtensions::ClassMethods
+  # Creates a reference to a FileBlob storing a file.
+  #
+  # `has_file_blob :file` creates the following
+  #
+  # * file - synthetic accessor
+  # * file_blob - belongs_to relationship pointing to a FileBlob
+  # * file_blob_id - attribute used by the belongs_to relationship; stores the
+  #   SHA-256 of the file's contents
+  # * file_size - attribute storing the file's length in bytes; this is stored
+  #   in the model as an optimization, so the length can be displayed / used
+  #   for decisions without fetching the blob model storing the contents
+  # * file_mime_type - attribute storing the MIME type associated with the
+  #   file; this is stored outside the blob model because it is possible to
+  #   have the same bytes uploaded with different MIME types
+  # * file_original_name - attribute storing the name supplied by the browser
+  #   that uploaded the file; this should not be trusted, as it is controlled
+  #   by the user
+  #
+  # @param [String] attribute_name the name of the relationship pointing to the
+  #     file blob, and the root of the names of the related attributes
+  # @param [Hash{Symbol, Object}] options
+  # @option options [String] blob_model the name of the model used to store the
+  #     file's contents; defaults to 'FileBlob'
+  # @option options [Boolean] allow_nil if true, allows saving a model without
+  #     an associated file
+  def has_file_blob(attribute_name = 'file', options = {})
+    blob_model = (options[:blob_model] || 'FileBlob'.freeze).to_s
+    allow_nil = options[:allow_nil] || false
+
+    self.class_eval <<ENDRUBY, __FILE__, __LINE__ + 1
+      # Saves the old blob model id, so the de-referenced blob can be GCed.
+      before_save :#{attribute_name}_stash_old_blob, on: :update
+
+      # Checks if the de-referenced FileBlob in an update should be GCed.
+      after_update :#{attribute_name}_maybe_garbage_collect_old_blob
+
+      # Checks if the FileBlob of a deleted entry should be GCed.
+      after_destroy :#{attribute_name}_maybe_garbage_collect_blob
+
+      # The FileBlob storing the file's content.
+      belongs_to :#{attribute_name}_blob,
+          { class_name: #{blob_model.inspect} }, -> { select :id }
+
+      class #{attribute_name.to_s.classify}Proxy < FileBlobs::FileBlobProxy
+        # Creates a proxy for the given model.
+        #
+        # The proxied model remains constant for the life of the proxy.
+        def initialize(owner)
+          @owner = owner
+        end
+
+        # Virtual attribute that proxies to the model's _blob attribute.
+        #
+        # This attribute does not have a corresponding setter because a _blob
+        # setter would encourage sub-optimal code. The owner model's file blob
+        # setter should be used instead, as it has a fast path that avoids
+        # fetching the blob's data. By comparison, a _blob setter would always
+        # have to fetch the blob data, to determine the blob's size.
+        def blob
+          @owner.#{attribute_name}_blob
+        end
+
+        # Virtual attribute that proxies to the model's _mime_type attribute.
+        def mime_type
+          @owner.#{attribute_name}_mime_type
+        end
+        def mime_type=(new_mime_type)
+          @owner.#{attribute_name}_mime_type = new_mime_type
+        end
+
+        # Virtual attribute that proxies to the model's _original_name attribute.
+        def original_name
+          @owner.#{attribute_name}_original_name
+        end
+        def original_name=(new_name)
+          @owner.#{attribute_name}_original_name = new_name
+        end
+
+        # Virtual getter that proxies to the model's _size attribute.
+        #
+        # This attribute does not have a corresponding setter because the _size
+        # attribute automatically tracks the _data attribute, so it should not
+        # be set on its own.
+        def size
+          @owner.#{attribute_name}_size
+        end
+
+        # Virtual attribute that proxies to the model's _blob_id attribute.
+        #
+        # This attribute is an optimization that allows some code paths to
+        # avoid fetching the associated blob model. It should only be used in
+        # these cases.
+        #
+        # This attribute does not have a corresponding setter because the
+        # contents blob should be set using the model's _blob attribute (with
+        # the blob proxy), which updates the model _size attribute and checks
+        # that the blob is an instance of the correct blob model.
+        def blob_id
+          @owner.#{attribute_name}_blob_id
+        end
+
+        # Virtual attribute that proxies to the model's _data attribute.
+        def data
+          @owner.#{attribute_name}_data
+        end
+        def data=(new_data)
+          @owner.#{attribute_name}_data = new_data
+        end
+
+        # Reflection.
+        def blob_class
+          #{blob_model}
+        end
+        def allows_nil?
+          #{allow_nil}
+        end
+        attr_reader :owner
+      end
+
+      # Getter for the file's convenience proxy.
+      def #{attribute_name}
+        @_#{attribute_name}_proxy ||=
+            #{attribute_name.to_s.classify}Proxy.new self
+      end
+
+      # Convenience setter for all the file attributes.
+      #
+      # @param {ActionDispatch::Http::UploadedFile, Proxy} new_file either an
+      #     object representing a file uploaded to a controller, or an object
+      #     obtained from another model's blob accessor
+      def #{attribute_name}=(new_file)
+        if new_file.respond_to? :read
+          # ActionDispatch::Http::UploadedFile
+          self.#{attribute_name}_mime_type = new_file.content_type
+          self.#{attribute_name}_original_name = new_file.original_filename
+          self.#{attribute_name}_data = new_file.read
+        elsif new_file.respond_to? :blob_class
+          # Blob owner proxy.
+          self.#{attribute_name}_mime_type = new_file.mime_type
+          self.#{attribute_name}_original_name = new_file.original_name
+          if new_file.blob_class == #{blob_model}
+            # Fast path: when the two files are backed by the same blob table,
+            # we can create a new reference to the existing blob.
+            self.#{attribute_name}_blob_id = new_file.blob_id
+            self.#{attribute_name}_size = new_file.size
+          else
+            # Slow path: we need to copy data across blob tables.
+            self.#{attribute_name}_data = new_file.data
+          end
+        end
+      end
+
+      # Convenience getter for the file's content.
+      #
+      # @return [String] a string with the binary encoding that holds the
+      #     file's contents
+      def #{attribute_name}_data
+        # NOTE: we're not using the ActiveRecord association on purpose, so
+        #       that the large FileBlob doesn't hang off of the object
+        #       referencing it; this way, the blob's data can be
+        #       garbage-collected by the Ruby VM as early as possible
+        blob = #{blob_model}.where(id: #{attribute_name}_blob_id).first!
+        blob.data
+      end
+
+      # Convenience setter for the file's content.
+      #
+      # @param new_blob_contents [String] a string with the binary encoding
+      #     that holds the new file contents to be stored by this model
+      def #{attribute_name}_data=(new_blob_contents)
+        sha = new_blob_contents && #{blob_model}.id_for(new_blob_contents)
+        return if self.#{attribute_name}_blob_id == sha
+
+        if sha && #{blob_model}.where(id: sha).length == 0
+          self.#{attribute_name}_blob = #{blob_model}.new id: sha,
+              data: new_blob_contents
+        else
+          self.#{attribute_name}_blob_id = sha
+        end
+
+        self.#{attribute_name}_size =
+            new_blob_contents && new_blob_contents.bytesize
+      end
+
+      # Saves the old blob model id, so the de-referenced blob can be GCed.
+      def #{attribute_name}_stash_old_blob
+        @_#{attribute_name}_old_blob_id = #{attribute_name}_blob_id_change &&
+            #{attribute_name}_blob_id_change.first
+      end
+      private :#{attribute_name}_stash_old_blob
+
+      # Checks if the de-referenced blob model in an update should be GCed.
+      def #{attribute_name}_maybe_garbage_collect_old_blob
+        return unless @_#{attribute_name}_old_blob_id
+        old_blob = #{blob_model}.find @_#{attribute_name}_old_blob_id
+        old_blob.maybe_garbage_collect
+        @_#{attribute_name}_old_blob_id = nil
+      end
+      private :#{attribute_name}_maybe_garbage_collect_old_blob
+
+      # Checks if the FileBlob of a deleted entry should be GCed.
+      def #{attribute_name}_maybe_garbage_collect_blob
+        #{attribute_name}_blob && #{attribute_name}_blob.maybe_garbage_collect
+      end
+      private :#{attribute_name}_maybe_garbage_collect_blob
+
+      unless self.respond_to? :file_blob_id_attributes
+        @@file_blob_id_attributes = {}
+        cattr_reader :file_blob_id_attributes, instance_reader: false
+      end
+
+      unless self.respond_to? :file_blob_eligible_for_garbage_collection?
+        # Checks if a contents blob is referenced by a model of this class.
+        #
+        # @param {FileBlobs::BlobModel} file_blob a blob to be checked
+        def self.file_blob_eligible_for_garbage_collection?(file_blob)
+          attributes = file_blob_id_attributes[file_blob.class.name]
+          file_blob_id = file_blob.id
+
+          # TODO(pwnall): Use or to issue a single SQL query for multiple
+          #     attributes.
+          !attributes.any? do |attribute|
+            where(attribute => file_blob_id).exists?
+          end
+        end
+      end
+ENDRUBY
+
+    file_blob_id_attributes[blob_model] ||= []
+    file_blob_id_attributes[blob_model] << :"#{attribute_name}_blob_id"
+
+    if !allow_nil
+      self.class_eval <<ENDRUBY, __FILE__, __LINE__ + 1
+        validates :#{attribute_name}_blob, presence: true
+        validates :#{attribute_name}_mime_type, presence: true
+        validates :#{attribute_name}_size, presence: true
+ENDRUBY
+    end
+  end
+end  # module FileBlobs::ActiveRecordExtensions::ClassMethods
+
+end  # namespace FileBlobs
+
+ActiveRecord::Base.class_eval do
+  include FileBlobs::ActiveRecordExtensions
+end

data/lib/file_blobs_rails/active_record_fixture_set_extensions.rb

@@ -0,0 +1,58 @@
+require 'base64'
+
+require 'active_record/fixtures'
+
+module FileBlobs
+
+# Module mixed into ActiveRecord::FixtureSet.
+module ActiveRecordFixtureSetExtensions
+  # Computes the ID assigned to a blob.
+  #
+  # @param [String] path the path of the file whose contents is used in the
+  #   fixture, relative to the Rails application's test/fixtures directory
+  # @return [String] the ID used to represent the blob contents
+  def file_blob_id(path)
+    file_path = Rails.root.join('test/fixtures'.freeze).join(path)
+    blob_contents = File.binread file_path
+
+    # This needs to be kept in sync with blob_model.rb.
+    Base64.urlsafe_encode64(Digest::SHA256.digest(blob_contents)).inspect
+  end
+
+  # The contents of a blob, in a YAML-friendly format.
+  #
+  # @param [String] path the path of the file whose contents is used in the
+  #   fixture, relative to the Rails application's test/fixtures directory
+  # @param [Hash] options optionally specify the current indentation level
+  # @option options [Integer] indent the number of spaces that the current line
+  #   in the YAML fixture file is indented by
+  # @return [String] the base64-encoded blob contents
+  def file_blob_data(path, options = {})
+    # The line with base64 data must be indented further than the current line.
+    indent = ' ' * ((options[:indent] || 2) + 2)
+
+    file_path = Rails.root.join('test/fixtures'.freeze).join(path)
+    blob_contents = File.binread file_path
+    base64_data = Base64.encode64 blob_contents
+    base64_data.gsub! "\n", "\n#{indent}"
+    base64_data.strip!
+
+    "!!binary |\n#{indent}#{base64_data}"
+  end
+
+  # The number of bytes in a file.
+  #
+  # @param [String] path the path of the file whose contents is used in the
+  #   fixture, relative to the Rails application's test/fixtures directory
+  # @return [Integer] the nubmer of bytes in the file
+  def file_blob_size(path)
+    file_path = Rails.root.join('test/fixtures'.freeze).join(path)
+    File.stat(file_path).size
+  end
+end  # module FileBlobs::ActiveRecordFixtureSetExtensions
+
+end  # namespace FileBlobs
+
+ActiveRecord::FixtureSet.context_class.class_eval do
+  include FileBlobs::ActiveRecordFixtureSetExtensions
+end

data/lib/file_blobs_rails/active_record_migration_extensions.rb

@@ -0,0 +1,31 @@
+require 'active_record'
+
+module FileBlobs
+
+# Module mixed into ActiveRecord::Migration.
+module ActiveRecordMigrationExtensions
+  # Creates the table used to hold file blobs.
+  #
+  # @param [Symbol] table_name the name of the table used to hold file data
+  # @param [Hash<Symbol, Object>] options
+  # @option options [Integer] blob_limit the maximum file size that can be
+  #     stored in the table; defaults to 1 megabyte
+  def create_file_blobs_table(table_name = :file_blobs, options = {}, &block)
+    blob_limit = options[:blob_limit] || 1.megabyte
+
+    create_table table_name, id: false do |t|
+      t.primary_key :id, :string, null: false, limit: 48
+      t.binary :data, null: false, limit: blob_limit
+
+      # Block capturing and calling is a bit slower than using yield. This is
+      # not a concern because migrations aren't run in tight loops.
+      block.call t
+    end
+  end
+end  # module FileBlobs::ActiveRecordMigrationExtensions
+
+end  # namespace FileBlobs
+
+ActiveRecord::Migration.class_eval do
+  include FileBlobs::ActiveRecordMigrationExtensions
+end

data/lib/file_blobs_rails/active_record_table_definition_extensions.rb

@@ -0,0 +1,35 @@
+require 'active_record'
+
+module FileBlobs
+
+# Module mixed into ActiveRecord::ConnectionAdapters::TableDefinition.
+module ActiveRecordTableDefinitionExtensions
+  # Creates the table used to hold file blobs.
+  #
+  # @param [Symbol] table_name the name of the table used to hold file data
+  # @param [Hash<Symbol, Object>] options
+  # @option options [Boolean] null true
+  # @option options [Integer] blob_limit the maximum file size that can be
+  #     stored in the table; defaults to 1 megabyte
+  def file_blob(column_name_base = :file, options = {}, &block)
+    allow_null = options[:null] || false
+    mime_type_limit = options[:mime_type_limit] || 64
+    file_name_limit = options[:file_name_limit] || 256
+
+    # The index is needed for garbage-collection eligibility checks.
+    string :"#{column_name_base}_blob_id", limit: 48, null: allow_null,
+           index: true
+
+    integer :"#{column_name_base}_size", null: allow_null
+    string :"#{column_name_base}_mime_type", limit: mime_type_limit,
+           null: allow_null
+    string :"#{column_name_base}_original_name", limit: file_name_limit,
+           null: allow_null
+  end
+end  # module FileBlobs::ActiveRecordTableDefinitionExtensions
+
+end  # namespace FileBlobs
+
+ActiveRecord::ConnectionAdapters::TableDefinition.class_eval do
+  include FileBlobs::ActiveRecordTableDefinitionExtensions
+end

data/lib/file_blobs_rails/active_support_test_extensions.rb

@@ -0,0 +1,44 @@
+require 'base64'
+
+require 'active_support'
+
+module FileBlobs
+
+# Module mixed into ActiveRecord::FixtureSet.
+module ActiveSupportTestFixtures
+  # The contents of a blob.
+  #
+  # @param [String] path the path of the file whose contents is used in the
+  #   fixture, relative to the Rails application's test/fixtures directory
+  # @return [String] the blob contents
+  def file_blob_data(path)
+    file_path = Rails.root.join('test/fixtures'.freeze).join(path)
+    File.binread file_path
+  end
+
+  # Computes the ID assigned to a blob.
+  #
+  # @param [String] path the path of the file whose contents is used in the
+  #   fixture, relative to the Rails application's test/fixtures directory
+  # @return [String] the ID used to represent the blob contents
+  def file_blob_id(path)
+    # This needs to be kept in sync with blob_model.rb.
+    Base64.urlsafe_encode64(Digest::SHA256.digest(file_blob_data(path)))
+  end
+
+  # The size of a blob.
+  #
+  # @param [String] path the path of the file whose contents is used in the
+  #   fixture, relative to the Rails application's test/fixtures directory
+  # @return [String] the blob contents
+  def file_blob_size(path)
+    file_path = Rails.root.join('test/fixtures'.freeze).join(path)
+    File.stat(file_path).size
+  end
+end  # module FileBlobs::ActiveSupportTestFixtures
+
+end  # namespace FileBlobs
+
+ActiveSupport::TestCase.class_eval do
+  include FileBlobs::ActiveSupportTestFixtures
+end