tessa 1.2.3 → 6.0.0.rc1

data/lib/tessa/asset/failure.rb

@@ -1,37 +0,0 @@
-require 'delegate'
-
-class Tessa::Asset::Failure < SimpleDelegator
-  attr_reader :message
-
-  def initialize(id:, message:)
-    @message = message
-    super(::Tessa::Asset.new(id: id))
-  end
-
-  def self.factory(id:, response:)
-    new(id: id, message: message_from_status(response.status))
-  end
-
-  def self.message_from_status(status)
-    case status.to_s
-    when /5\d{2}/
-      "The service is unavailable at this time."
-    when /4\d{2}/
-      "There was a problem retrieving the data for this asset."
-    else
-      "An error occurred."
-    end
-  end
-
-  def failure?
-    true
-  end
-
-  def meta
-    {
-      name: "Not Found",
-      size: "0",
-      mime_type: "application/octet-stream"
-    }
-  end
-end

data/lib/tessa/asset.rb

@@ -1,47 +0,0 @@
-module Tessa
-  class Asset
-    include Virtus.model
-    extend ResponseFactory
-
-    attribute :id, Integer
-    attribute :status, String
-    attribute :strategy, String
-    attribute :meta, Hash[Symbol => String]
-    attribute :public_url, String
-    attribute :private_url, String
-    attribute :private_download_url, String
-    attribute :delete_url, String
-
-    def complete!(connection: Tessa.config.connection)
-      Asset.new_from_response connection.patch("/assets/#{id}/completed")
-    end
-
-    def cancel!(connection: Tessa.config.connection)
-      Asset.new_from_response connection.patch("/assets/#{id}/cancelled")
-    end
-
-    def delete!(connection: Tessa.config.connection)
-      Asset.new_from_response connection.delete("/assets/#{id}")
-    end
-
-    def self.find(*ids,
-                  connection: Tessa.config.connection)
-      new_from_response connection.get("/assets/#{ids.join(",")}")
-    end
-
-    def self.create(file:, **options)
-      default_options = {
-        size: File.size(file),
-        name: File.basename(file),
-        date: File.mtime(file),
-      }
-      Upload.create(default_options.merge(options)).upload_file(file)
-    end
-
-    def failure?
-      false
-    end
-  end
-end
-
-require 'tessa/asset/failure'

data/lib/tessa/asset_change.rb

@@ -1,49 +0,0 @@
-module Tessa
-  class AssetChange
-    include Virtus.model
-
-    attribute :id, Integer
-    attribute :action, String
-
-    def initialize(args={})
-      case args
-      when Array
-        id, attributes = args
-        super attributes.merge(id: id)
-      else
-        super
-      end
-    end
-
-    def apply
-      if add?
-        asset.complete!
-      elsif remove?
-        asset.delete!
-      end
-    end
-
-    def hash
-      [id, action].hash
-    end
-
-    def eql?(b)
-      self.class == b.class &&
-        self.hash == b.hash
-    end
-
-    def add?
-      action == 'add'
-    end
-
-    def remove?
-      action == 'remove'
-    end
-
-    private
-
-    def asset
-      Tessa::Asset.new(id: id)
-    end
-  end
-end

data/lib/tessa/asset_change_set.rb

@@ -1,49 +0,0 @@
-module Tessa
-  class AssetChangeSet
-    include Virtus.model
-
-    attribute :changes, Array[AssetChange]
-    attribute :scoped_ids, Array[Integer]
-
-    def scoped_ids=(new_ids)
-      super new_ids.compact
-    end
-
-    def scoped_changes
-      changes.select { |change| scoped_ids.include?(change.id) }
-    end
-
-    def apply
-      scoped_changes.uniq.each(&:apply)
-    end
-
-    def +(b)
-      self.changes = (self.changes + b.changes).uniq
-      self.scoped_ids = (self.scoped_ids + b.scoped_ids).uniq
-      self
-    end
-
-    def add(value)
-      id = id_from_asset(value)
-      changes << AssetChange.new(id: id, action: "add")
-      scoped_ids << id
-    end
-
-    def remove(value)
-      id = id_from_asset(value)
-      changes << AssetChange.new(id: id, action: "remove")
-      scoped_ids << id
-    end
-
-    private
-
-    def id_from_asset(value)
-      case value
-      when Asset
-        value.id
-      when Fixnum
-        value
-      end
-    end
-  end
-end

data/lib/tessa/config.rb

@@ -1,24 +0,0 @@
-module Tessa
-  class Config
-    include Virtus.model
-
-    DEFAULT_STRATEGY = "default"
-
-    attribute :username, String, default: -> (*_) { ENV['TESSA_USERNAME'] }
-    attribute :password, String, default: -> (*_) { ENV['TESSA_PASSWORD'] }
-    attribute :url, String, default: -> (*_) { ENV['TESSA_URL'] }
-    attribute :strategy, String, default: -> (*_) { ENV['TESSA_STRATEGY'] || DEFAULT_STRATEGY }
-
-    def connection
-      @connection ||= Faraday.new(url: url) do |conn|
-        if conn.respond_to?(:basic_auth)
-          conn.basic_auth username, password
-        else # Faraday >= 1.0
-          conn.request :authorization, :basic, username, password
-        end
-        conn.request :url_encoded
-        conn.adapter Faraday.default_adapter
-      end
-    end
-  end
-end

data/lib/tessa/controller_helpers.rb

@@ -1,16 +0,0 @@
-module Tessa
-  module ControllerHelpers
-
-    def params_for_asset(changes)
-      Tessa::AssetChangeSet.new(
-        changes: changes,
-        scoped_ids: tessa_upload_asset_ids,
-      )
-    end
-
-    def tessa_upload_asset_ids
-      session[:tessa_upload_asset_ids] ||= []
-    end
-
-  end
-end

data/lib/tessa/jobs/migrate_assets_job.rb

@@ -1,225 +0,0 @@
-require 'open-uri'
-
-class Tessa::MigrateAssetsJob < ActiveJob::Base
-
-  queue_as :low
-
-  def perform(*args)
-    options = args&.extract_options!
-    options = {
-      batch_size: 10,
-      interval: 10.minutes.to_i
-    }.merge!(options&.symbolize_keys || {})
-
-    interval = options[:interval].seconds
-    processing_state = args.first ? Marshal.load(args.first) : load_models_from_registry
-
-    if processing_state.fully_processed?
-      Rails.logger.info("Nothing to do - all models have transitioned to ActiveStorage")
-      return
-    end
-
-    processing_state.batch_count = 0
-    while processing_state.batch_count < options[:batch_size]
-      model_state = processing_state.next_model
-
-      process(processing_state, model_state, options)
-
-      break if processing_state.fully_processed?
-    end
-
-    if processing_state.fully_processed?
-      Rails.logger.info("Finished processing all Tessa assets")
-    else
-      remaining_batches = (processing_state.count / options[:batch_size].to_f).ceil
-
-      Rails.logger.info("Continuing processing in #{interval}, "\
-        "ETA #{(remaining_batches * interval).from_now}. "\
-        "Working on #{processing_state.next_model.next_field}")
-
-      processing_state.batch_count = 0
-      self.class.set(wait: interval)
-        .perform_later(Marshal.dump(processing_state), options)
-    end
-  end
-
-  private
-
-  def process(processing_state, model_state, options)
-    while processing_state.batch_count < options[:batch_size]
-      field_state = model_state.next_field
-
-      process_field(processing_state, field_state, options)
-
-      return if model_state.fully_processed?
-    end
-  end
-
-  def process_field(processing_state, field_state, options)
-    while processing_state.batch_count < options[:batch_size]
-      remaining = options[:batch_size] - processing_state.batch_count
-
-      next_batch = field_state.query
-        .offset(field_state.offset)
-        .limit(remaining)
-
-      next_batch.each_with_index do |record, idx|
-        begin
-          # Wait 1 second in between records to slow things down and let the
-          # system process for a bit
-          sleep 1 if idx > 0
-
-          reupload(record, field_state)
-          Rails.logger.info("#{record.class}#{record.id}##{field_state.field_name}: success")
-          field_state.success_count += 1
-        rescue OpenURI::HTTPError => ex
-          if ex.message == "404 Not Found"
-            # clear out the field if the asset is missing
-            record.public_send("#{field_state.tessa_field.name}=", nil)
-            record.save!
-          else
-            Rails.logger.error("#{record.class}#{record.id}##{field_state.field_name}: error - #{ex}")
-          end
-          field_state.offset += 1
-        rescue StandardError => ex
-          Rails.logger.error("#{record.class}#{record.id}##{field_state.field_name}: error - #{ex}")
-          field_state.offset += 1
-        ensure
-          processing_state.batch_count += 1
-        end
-      end
-
-      return if field_state.fully_processed?
-    end
-  end
-
-  def reupload(record, field_state)
-    if field_state.tessa_field.multiple?
-      reupload_multiple(record, field_state)
-    else
-      reupload_single(record, field_state)
-    end    
-  end
-
-  def reupload_single(record, field_state)
-    # models with ActiveStorage uploads have nil in the column, but if you call
-    # the method it hits the dynamic extensions and gives you the blob key
-    database_id = record.attributes["_tessa_#{field_state.tessa_field.id_field}"]
-    return unless database_id
-
-    asset = Tessa::Asset.find(database_id)
-
-    attachable = {
-      io: URI.open(asset.private_download_url),
-      filename: asset.meta[:name]
-    }
-
-    record.public_send("#{field_state.tessa_field.name}=", attachable)
-    record.save!
-  end
-
-  def reupload_multiple(record, field_state)
-    database_ids = record.attributes["_tessa_#{field_state.tessa_field.id_field}"]
-    return unless database_ids
-    
-    assets = Tessa::Asset.find(database_ids)
-
-    attachables = assets.map do |asset|
-      {
-        io: URI.open(asset.private_download_url),
-        filename: asset.meta[:name]
-      }
-    end
-
-    record.public_send("#{field_state.tessa_field.name}=", attachables)
-    record.save!
-  end
-
-  def load_models_from_registry
-    Rails.application.eager_load!
-
-    # Load all Tessa models that can have attachments (not form objects)
-    models = Tessa.model_registry
-      .select { |m| m.respond_to?(:has_one_attached) }
-
-    # Initialize our Record Keeping object
-    ProcessingState.initialize_from_models(models)
-  end
-
-  ProcessingState = Struct.new(:model_queue, :batch_count) do
-    def self.initialize_from_models(models)
-      new(
-        models.map do |model|
-          ModelProcessingState.initialize_from_model(model)
-        end,
-        0
-      )
-    end
-
-    def next_model
-      model_queue.detect { |i| !i.fully_processed? }
-    end
-
-    def fully_processed?
-      model_queue.all?(&:fully_processed?)
-    end
-
-    def count
-      model_queue.sum { |m| m.field_queue.sum { |f| f.count - f.offset } }
-    end
-  end
-
-  ModelProcessingState = Struct.new(:class_name, :field_queue) do
-    def self.initialize_from_model(model)
-      new(
-        model.name,
-        model.tessa_fields.map do |name, _|
-          FieldProcessingState.initialize_from_model(model, name)
-        end
-      )
-    end
-
-    def next_field
-      field_queue.detect { |i| !i.fully_processed? }
-    end
-
-    def model
-      @model ||= class_name.constantize
-    end
-
-    def fully_processed?
-      field_queue.all?(&:fully_processed?)
-    end
-  end
-
-  FieldProcessingState = Struct.new(:class_name, :field_name, :offset, :success_count) do
-    def self.initialize_from_model(model, field_name)
-      new(
-        model.name,
-        field_name,
-        0,
-        0
-      )
-    end
-
-    def model
-      @model ||= class_name.constantize
-    end
-
-    def tessa_field
-      model.tessa_fields[field_name]
-    end
-
-    def query
-      model.where.not(Hash[tessa_field.id_field, nil])
-    end
-
-    def count
-      query.count
-    end
-
-    def fully_processed?
-      offset >= count
-    end
-  end
-end

data/lib/tessa/model/dynamic_extensions.rb

@@ -1,162 +0,0 @@
-require 'forwardable'
-
-class Tessa::DynamicExtensions
-  extend Forwardable
-
-  attr_reader :field
-
-  def name
-    field.name
-  end
-
-  def initialize(field)
-    @field = field
-  end
-
-  class SingleRecord < ::Tessa::DynamicExtensions
-    def build(mod)
-      mod.class_eval <<~CODE, __FILE__, __LINE__ + 1
-          def #{name}
-            # has_one_attached defines the getter using class_eval so we can't call
-            # super() here.
-            if #{name}_attachment.present?
-              return Tessa::ActiveStorage::AssetWrapper.new(#{name}_attachment)
-            end
-
-            # fall back to old Tessa fetch if not present
-            if field = self.class.tessa_fields["#{name}".to_sym]
-              @#{name} ||= fetch_tessa_remote_assets(field.id(on: self))
-            end
-          end
-
-          def #{field.id_field}
-            # Use the attachment's key
-            return #{name}_attachment.key if #{name}_attachment.present?
-
-            # fallback to Tessa's database column
-            super
-          end
-
-          def #{name}=(attachable)
-            # Every new upload is going to ActiveStorage
-            a = @active_storage_attached_#{name} ||=
-              ::ActiveStorage::Attached::One.new("#{name}", self, dependent: :purge_later)
-            
-            case attachable
-            when Tessa::AssetChangeSet
-              attachable.changes.select(&:remove?).each { a.detach }
-              attachable.changes.select(&:add?).each do |change|
-                next if #{field.id_field} == change.id
-
-                a.attach(change.id)
-              end
-            when nil
-              a.detach
-            else
-              a.attach(attachable)
-            end
-
-            # overwrite the tessa ID in the database
-            self.#{field.id_field} = nil
-          end
-
-          def attributes
-            super.merge({
-              '#{field.id_field}' => #{field.id_field},
-              '_tessa_#{field.id_field}' => super['#{field.id_field}']
-            })
-          end
-        CODE
-      mod
-    end
-  end
-
-  class MultipleRecord < ::Tessa::DynamicExtensions
-    def build(mod)
-      mod.class_eval <<~CODE, __FILE__, __LINE__ + 1
-          def #{name}
-            field = self.class.tessa_fields["#{name}".to_sym]
-            tessa_ids = field.id(on: self) - #{name}_attachments.map(&:key)
-            
-            @#{name} ||= [
-              *#{name}_attachments.map { |a| Tessa::ActiveStorage::AssetWrapper.new(a) },
-              *fetch_tessa_remote_assets(tessa_ids)
-            ]
-          end
-
-          def #{field.id_field}
-            [
-              # Use the attachment's key
-              *#{name}_attachments.map(&:key),
-              # include from Tessa's database column
-              *super
-            ]
-          end
-
-          def #{name}=(attachables)
-            # Every new upload is going to ActiveStorage
-            a = @active_storage_attached_#{name} ||=
-              ::ActiveStorage::Attached::Many.new("#{name}", self, dependent: :purge_later)
-
-            case attachables
-            when Tessa::AssetChangeSet
-              attachables.changes.select(&:remove?).each do |change|
-                if existing = #{name}_attachments.find { |a| a.key == change.id }
-                  existing.destroy
-                else
-                  ids = self.#{field.id_field}
-                  ids.delete(change.id.to_i)
-                  self.#{field.id_field} = ids.any? ? ids : nil
-                end
-              end
-              attachables.changes.select(&:add?).each do |change|
-                next if #{field.id_field}.include? change.id
-
-                a.attach(change.id)
-              end
-            when nil
-              a.detach
-              self.#{field.id_field} = nil
-            else
-              a.attach(*attachables)
-              self.#{field.id_field} = nil
-            end
-          end
-
-          def attributes
-            super.merge({
-              '#{field.id_field}' => #{field.id_field},
-              '_tessa_#{field.id_field}' => super['#{field.id_field}']
-            })
-          end
-        CODE
-      mod
-    end
-  end
-
-  class SingleFormObject < ::Tessa::DynamicExtensions
-    def build(mod)
-      mod.class_eval <<~CODE, __FILE__, __LINE__ + 1
-          attr_accessor :#{name}_id
-          attr_writer :#{name}
-          def #{name}
-            @#{name} ||= fetch_tessa_remote_assets(#{name}_id)
-          end
-        CODE
-      mod
-    end
-  end
-
-  class MultipleFormObject < ::Tessa::DynamicExtensions
-    def build(mod)
-      mod.class_eval <<~CODE, __FILE__, __LINE__ + 1
-          attr_accessor :#{name}_ids
-          attr_writer :#{name}
-          def #{name}
-            @#{name} ||= fetch_tessa_remote_assets(#{name}_ids)
-          end
-        CODE
-      mod
-    end
-  end
-end

data/lib/tessa/model/field.rb

@@ -1,77 +0,0 @@
-module Tessa
-  module Model
-    class Field
-      include Virtus.model
-
-      attribute :model
-      attribute :name, String
-      attribute :multiple, Boolean, default: false
-      attribute :id_field, String
-
-      def id_field
-        super || "#{name}#{default_id_field_suffix}"
-      end
-
-      def ids(on:)
-        [*id(on: on)]
-      end
-
-      def id(on:)
-        on.public_send(id_field)
-      end
-
-      def apply(set, on:)
-        ids = ids(on: on)
-
-        set.scoped_changes.each do |change|
-          if change.add?
-            ids << change.id
-          elsif change.remove?
-            ids.delete change.id
-          end
-        end
-
-        if multiple?
-          on.public_send(id_field_writer, ids)
-        else
-          on.public_send(id_field_writer, ids.first)
-        end
-      end
-
-      def change_set_for(value)
-        case value
-        when AssetChangeSet
-          value
-        when Array
-          value.map { |item| change_set_for(item) }.reduce(:+)
-        when Asset
-          AssetChangeSet.new.tap { |set| set.add(value) }
-        else
-          AssetChangeSet.new
-        end
-      end
-
-      def difference_change_set(subtrahend_ids, on:)
-        AssetChangeSet.new.tap do |change_set|
-          (ids(on: on) - subtrahend_ids).each do |id|
-            change_set.remove(id)
-          end
-        end
-      end
-
-      private
-
-      def id_field_writer
-        "#{id_field}="
-      end
-
-      def default_id_field_suffix
-        if multiple
-          "_ids"
-        else
-          "_id"
-        end
-      end
-    end
-  end
-end