tessa 2.0 → 6.0.0.rc2

data/lib/tessa/model.rb

@@ -1,94 +0,0 @@
-require 'tessa/model/field'
-require 'tessa/model/dynamic_extensions'
-require 'tessa/active_storage/asset_wrapper'
-
-module Tessa
-  module Model
-
-    def self.included(base)
-      base.send :include, InstanceMethods
-      base.extend ClassMethods
-
-      Tessa.model_registry << base
-    end
-
-    module InstanceMethods
-
-      def pending_tessa_change_sets
-        @pending_tessa_change_sets ||= Hash.new { AssetChangeSet.new }
-      end
-
-      def apply_tessa_change_sets
-        # Pretend like the application was successful but we didn't do anything
-        # because everything is in ActiveStorage now
-        pending_tessa_change_sets.clear
-      end
-
-      def remove_all_tessa_assets
-        self.class.tessa_fields.each do |name, field|
-          change_set = pending_tessa_change_sets[name]
-          field.ids(on: self).each do |asset_id|
-            change_set.remove(asset_id)
-          end
-          pending_tessa_change_sets[name] = change_set
-        end
-      end
-
-      def fetch_tessa_remote_assets(ids)
-        # This should just always return Tessa::AssetFailure
-        Tessa.find_assets(ids)
-      end
-    end
-
-    module ClassMethods
-      def asset(name, args={})
-        field = tessa_fields[name] = Field.new(args.merge(name: name))
-        
-        multiple = args[:multiple]
-
-
-        if respond_to?(:has_one_attached)
-          if multiple
-            has_many_attached(name)
-          else
-            has_one_attached(name)
-          end
-
-          # We have to replace the after_destroy_commit callback added above
-          callbacks = get_callbacks(:commit)
-          callbacks.delete(callbacks.to_a.last)
-          after_destroy_commit { public_send("#{name}_attachment")&.purge_later }
-        end
-
-        dynamic_extensions =
-          if respond_to?(:has_one_attached)
-            if multiple
-              ::Tessa::DynamicExtensions::MultipleRecord.new(field)
-            else
-              ::Tessa::DynamicExtensions::SingleRecord.new(field)
-            end
-          else
-            if multiple
-              ::Tessa::DynamicExtensions::MultipleFormObject.new(field)
-            else
-              ::Tessa::DynamicExtensions::SingleFormObject.new(field)
-            end
-          end
-        include dynamic_extensions.build(Module.new)
-
-        # Undefine the activestorage default attribute method so it falls back
-        # to our dynamic module
-        remove_method "#{name}" rescue nil
-        remove_method "#{name}=" rescue nil
-      end
-
-      def tessa_fields
-        @tessa_fields ||= {}
-      end
-
-      def inherited(subclass)
-        subclass.instance_variable_set(:@tessa_fields, @tessa_fields.dup)
-      end
-    end
-  end
-end

data/lib/tessa/rack_upload_proxy.rb

@@ -1,41 +0,0 @@
-module Tessa
-  class RackUploadProxy
-
-    def call(env)
-      request = Rack::Request.new(env)
-      ::ActiveStorage::Current.host ||= request.base_url
-
-      # Call in to ActiveStorage to create a DirectUpload blob
-      params = env['rack.request.form_hash']
-
-      blob = ::ActiveStorage::Blob.create_before_direct_upload!({
-        filename: params["name"],
-        byte_size: params["size"],
-        content_type: params["mime_type"],
-        checksum: params["checksum"]
-      })
-
-      env['rack.session'][:tessa_upload_asset_ids] ||= []
-      env['rack.session'][:tessa_upload_asset_ids] << blob.signed_id
-
-      response = {
-        asset_id: blob.signed_id,
-        upload_url: blob.service_url_for_direct_upload,
-        upload_method: 'PUT', # ActiveStorage is always PUT
-        upload_headers: blob.service_headers_for_direct_upload
-      }
-
-      [200, {"Content-Type" => "application/json"}, [response.to_json]]
-    rescue Tessa::RequestFailed
-      [500, {"Content-Type" => "application/json"}, [{ "error" => "Failed to retreive upload URL" }.to_json]]
-    rescue ActiveRecord::NotNullViolation => e
-      [400, {"Content-Type" => "application/json"}, [{ "error" => e.message }.to_json]]
-    end
-
-    def self.call(*args)
-      new.call(*args)
-    end
-
-  end
-end
-

data/lib/tessa/response_factory.rb

@@ -1,15 +0,0 @@
-module Tessa
-  module ResponseFactory
-
-    def new_from_response(response)
-      raise RequestFailed.new("Tessa responded with #{response.status}", response) unless response.success?
-      case json = JSON.parse(response.body)
-      when Array
-        json.map { |record| new record }
-      when Hash
-        new json
-      end
-    end
-
-  end
-end

data/lib/tessa/upload/uploads_file.rb

@@ -1,18 +0,0 @@
-class Tessa::Upload::UploadsFile
-  attr_reader :upload, :connection
-
-  def initialize(upload:, connection: self.class.connection_factory)
-    @upload = upload
-    @connection = connection
-  end
-
-  def call(file)
-    connection
-      .public_send(upload.upload_method, upload.upload_url, File.read(file))
-      .success?
-  end
-
-  def self.connection_factory
-    Tessa::FakeConnection.new
-  end
-end

data/lib/tessa/upload.rb

@@ -1,31 +0,0 @@
-module Tessa
-  class Upload
-    include Virtus.model
-    extend ResponseFactory
-
-    attribute :asset_id, Integer
-    attribute :upload_url, String
-    attribute :upload_method, String
-
-    def upload_file(file)
-      if UploadsFile.new(upload: self).(file)
-        asset.complete!
-      else
-        asset.cancel!
-        false
-      end
-    end
-
-    def self.create(connection: Tessa.config.connection,
-                    strategy: Tessa.config.strategy,
-                    **options)
-      new_from_response connection.post('/uploads', options.merge(strategy: strategy))
-    end
-
-    private def asset
-      Asset.new(id: asset_id)
-    end
-  end
-end
-
-require 'tessa/upload/uploads_file'

data/lib/tessa/view_helpers.rb

@@ -1,23 +0,0 @@
-module Tessa
-  module ViewHelpers
-    def tessa_image_tag(asset, private: false)
-      handle_asset_failure(asset) do
-        image_tag(
-          private ? asset.private_url : asset.public_url
-        )
-      end
-    end
-
-    private
-
-    def handle_asset_failure(asset)
-      if asset.failure?
-        content_tag(:div, asset.message, class: "tessa-asset-failure")
-      else
-        yield
-      end
-    end
-  end
-end
-
-ActionView::Base.send :include, Tessa::ViewHelpers if defined?(ActionView)

data/spec/dummy/app/models/multiple_asset_model.rb

@@ -1,8 +0,0 @@
-class MultipleAssetModel < ActiveRecord::Base
-  # Necessary to have an array of integers in sqlite
-  serialize :another_place, Array
-
-  include Tessa::Model
-
-  asset :multiple_field, multiple: true, id_field: "another_place"
-end

data/spec/support/remote_call_macro.rb

@@ -1,40 +0,0 @@
-RSpec.shared_examples_for "remote call macro" do |method, path, return_type|
-  let(:remote_response) { {} }
-  let(:faraday_stubs) {
-    Faraday::Adapter::Test::Stubs.new do |stub|
-      stub.send(method, path) { |env| [200, {}, remote_response.to_json] }
-    end
-  }
-  let(:connection) { Faraday.new { |f| f.adapter :test, faraday_stubs } }
-  let(:call_args) { { connection: connection } }
-
-  it "calls #{method} method with #{path}" do
-    expect(connection).to receive(method).with(path, any_args).and_call_original
-    call
-  end
-
-  context "with no connection passed" do
-    let(:call_args) { {} }
-
-    it "defaults connection to Tessa.config.connection" do
-      expect(Tessa.config).to receive(:connection).and_return(connection)
-      expect(connection).to receive(method).and_call_original
-      call
-    end
-  end
-
-  context "when response is not successful" do
-    let(:connection) { Tessa::FakeConnection.new }
-
-    it "raises Tessa::RequestFailed" do
-      expect{ call }.to raise_error { |error|
-        expect(error).to be_a(Tessa::RequestFailed)
-      }
-    end
-  end
-
-  it "returns an instance of #{return_type}" do
-    expect(call).to be_a(return_type)
-  end
-end
-

data/spec/tessa/asset/failure_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tessa::Asset::Failure do
-  subject(:failure) { described_class.new(args) }
-  let(:id) { rand(100) }
-  let(:args) {
-    { id: id, message: "Test" }
-  }
-
-  describe "#initialize" do
-    it "sets id to attribute" do
-      expect(failure.id).to eq(args[:id])
-    end
-
-    it "sets message to attribute" do
-      expect(failure.message).to eq(args[:message])
-    end
-  end
-
-  describe ".factory" do
-    let(:message) { 'test message' }
-    let(:response) { double(status: 500) }
-    subject(:failure) { described_class.factory(id: id, response: response) }
-
-
-    it "returns instance of Failure" do
-      expect(described_class).to receive(:message_from_status)
-        .with(response.status).and_return(message)
-      expect(failure.id).to eq(id)
-      expect(failure.message).to eq(message)
-    end
-  end
-
-  it "responds like a blank asset" do
-    asset = Tessa::Asset.new
-    expect(failure.status).to eq(asset.status)
-    expect(failure.strategy).to eq(asset.strategy)
-    expect(failure.public_url).to eq(asset.public_url)
-    expect(failure.private_url).to eq(asset.private_url)
-    expect(failure.delete_url).to eq(asset.delete_url)
-  end
-
-  describe "#failure?" do
-    it "returns true" do
-      expect(failure).to be_failure
-    end
-  end
-end

data/spec/tessa/asset_change_set_spec.rb

@@ -1,198 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tessa::AssetChangeSet do
-  subject(:set) { described_class.new(args) }
-  let(:args) {
-    {
-      changes: Array.new(2) { Tessa::AssetChange.new },
-      scoped_ids: [1, 2],
-    }
-  }
-
-  describe "#initialize" do
-    it "sets :changes to attribute" do
-      expect(set.changes).to eq(args[:changes])
-    end
-
-    it "sets :scoped_ids to attribute" do
-      expect(set.scoped_ids).to eq([1, 2])
-    end
-
-    context "with various scoped_id input types" do
-      before { args[:scoped_ids] = ["1", 2, nil] }
-
-      it "ensures all values are integers and ignores nils" do
-        expect(set.scoped_ids).to eq([1, 2])
-      end
-    end
-
-    context "with hash format for changes" do
-      before do
-        args[:changes] = { "123" => { "action" => "add" }, "456" => { "action" => "remove" } }
-      end
-
-      it "initializes AssetChange objects for each hash" do
-        expect(set.changes[0].id).to eq(123)
-        expect(set.changes[0].action).to eq("add")
-        expect(set.changes[1].id).to eq(456)
-        expect(set.changes[1].action).to eq("remove")
-      end
-    end
-  end
-
-  describe "#scoped_changes" do
-    context "with changes not contained in scoped ids" do
-      let(:args) {
-        {
-          changes: [
-            Tessa::AssetChange.new(id: 1),
-            Tessa::AssetChange.new(id: 2),
-            Tessa::AssetChange.new(id: 3),
-            Tessa::AssetChange.new(id: 4)],
-          scoped_ids: [1, 2],
-        }
-      }
-
-      it "only returns the scoped changes" do
-        expect(set.scoped_changes.size).to eq(2)
-        expect(set.scoped_changes.map(&:id)).to eq([1, 2])
-      end
-    end
-  end
-
-  describe "#apply" do
-
-    context "with unscoped changes" do
-      let(:args) {
-        {
-          changes: [
-            Tessa::AssetChange.new(id: 1),
-            Tessa::AssetChange.new(id: 2)],
-          scoped_ids: [1],
-        }
-      }
-
-      it "calls apply on each scoped change" do
-        expect(set.changes[0]).to receive(:apply)
-        expect(set.changes[1]).not_to receive(:apply)
-        set.apply
-      end
-    end
-
-    context "with duplicate changes" do
-      let(:args) {
-        {
-          changes: [
-            Tessa::AssetChange.new(id: 1, action: 'remove'),
-            Tessa::AssetChange.new(id: 1, action: 'remove')],
-          scoped_ids: [1],
-        }
-      }
-
-      it "only calls apply on unique elements" do
-        expect(el = set.changes.uniq.first).to receive(:apply)
-        (set.changes - [el]).each { |o| expect(el).to_not receive(:apply) }
-        set.apply
-      end
-    end
-  end
-
-  describe "#+" do
-    let(:a) {
-      described_class.new(
-        changes: [Tessa::AssetChange.new(id: 1, action: 'add')],
-        scoped_ids: [1],
-      )
-    }
-    let(:b) {
-      described_class.new(
-        changes: [Tessa::AssetChange.new(id: 2, action: 'add')],
-        scoped_ids: [2],
-      )
-    }
-    subject(:sum) { a + b }
-
-    it "concatenates the values of changes" do
-      expect(sum.changes.collect(&:id)).to eq([1, 2])
-    end
-
-    it "concatenates the values of scoped_ids" do
-      expect(sum.scoped_ids).to eq([1, 2])
-    end
-
-    context "with duplicate entries" do
-      subject(:sum) { a + b + b }
-
-      it "only includes unique values" do
-        expect(sum.changes.collect(&:id)).to eq([1, 2])
-        expect(sum.scoped_ids).to eq([1, 2])
-      end
-    end
-  end
-
-  describe "#add" do
-    let(:args) { {} }
-    let(:asset) { Tessa::Asset.new(id: 1) }
-
-    shared_examples_for "adds the represented asset" do
-      it "adds an 'add' change for this asset" do
-        expect(set.changes[0].id).to eq(1)
-        expect(set.changes[0].action).to eq("add")
-      end
-
-      it "adds the asset id to the scoped_ids array" do
-        expect(set.scoped_ids).to eq([1])
-      end
-    end
-
-    context "when passed an asset" do
-      before do
-        set.add(asset)
-      end
-
-      it_behaves_like "adds the represented asset"
-    end
-
-    context "when passed an integer id" do
-      before do
-        set.add(1)
-      end
-
-      it_behaves_like "adds the represented asset"
-    end
-  end
-
-  describe "#remove" do
-    let(:args) { {} }
-    let(:asset) { Tessa::Asset.new(id: 1) }
-
-    shared_examples_for "removes the represented asset" do
-      it "adds a 'remove' change for this asset" do
-        expect(set.changes[0].id).to eq(1)
-        expect(set.changes[0].action).to eq("remove")
-      end
-
-      it "adds the asset id to the scoped_ids array" do
-        expect(set.scoped_ids).to eq([1])
-      end
-    end
-
-    context "when passed an asset" do
-      before do
-        set.remove(asset)
-      end
-
-      it_behaves_like "removes the represented asset"
-    end
-
-    context "when passed an integer id" do
-      before do
-        set.remove(1)
-      end
-
-      it_behaves_like "removes the represented asset"
-    end
-
-  end
-
-end

data/spec/tessa/asset_change_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tessa::AssetChange do
-  subject(:change) { described_class.new(args) }
-  let(:args) {
-    {
-      id: 123,
-      action: "add",
-    }
-  }
-
-  describe "#initialize" do
-    context "with hash args" do
-      it "sets id" do
-        expect(subject.id).to eq(123)
-      end
-
-      it "sets action" do
-        expect(subject.action).to eq("add")
-      end
-    end
-
-    context "with array arg" do
-      let(:args) { [123, { "action" => "add" }] }
-
-      it "sets id" do
-        expect(subject.id).to eq(123)
-      end
-
-      it "sets action" do
-        expect(subject.action).to eq("add")
-      end
-    end
-  end
-
-  describe "#apply" do
-    let(:asset) { instance_spy(Tessa::Asset) }
-    before do
-      expect(Tessa::Asset).to receive(:new).with(id: 123).and_return(asset)
-    end
-
-    context "with action 'add'" do
-      before { args[:action] = "add" }
-      it "calls complete! on asset with :id" do
-        change.apply
-        expect(asset).to have_received(:complete!)
-      end
-    end
-
-    context "with action 'remove'" do
-      before { args[:action] = "remove" }
-      it "calls delete! on asset with :id" do
-        change.apply
-        expect(asset).to have_received(:delete!)
-      end
-    end
-  end
-
-  describe "#add?" do
-    subject(:add?) { change.add? }
-
-    context "action = 'add'" do
-      before { change.action = 'add' }
-      it { is_expected.to eq(true) }
-    end
-
-    context "action != 'add'" do
-      before { change.action = 'something' }
-      it { is_expected.to eq(false) }
-    end
-  end
-
-  describe "#remove?" do
-    subject(:remove?) { change.remove? }
-
-    context "action = 'remove'" do
-      before { change.action = 'remove' }
-      it { is_expected.to eq(true) }
-    end
-
-    context "action != 'remove'" do
-      before { change.action = 'something' }
-      it { is_expected.to eq(false) }
-    end
-  end
-end