tessa 0.9.2 → 1.0.0.pre.rc1

data/app/javascript/activestorage/file_checksum.js

@@ -0,0 +1,53 @@
+import SparkMD5 from "spark-md5"
+
+const fileSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice
+
+export class FileChecksum {
+  static create(file, callback) {
+    const instance = new FileChecksum(file)
+    instance.create(callback)
+  }
+
+  constructor(file) {
+    this.file = file
+    this.chunkSize = 2097152 // 2MB
+    this.chunkCount = Math.ceil(this.file.size / this.chunkSize)
+    this.chunkIndex = 0
+  }
+
+  create(callback) {
+    this.callback = callback
+    this.md5Buffer = new SparkMD5.ArrayBuffer
+    this.fileReader = new FileReader
+    this.fileReader.addEventListener("load", event => this.fileReaderDidLoad(event))
+    this.fileReader.addEventListener("error", event => this.fileReaderDidError(event))
+    this.readNextChunk()
+  }
+
+  fileReaderDidLoad(event) {
+    this.md5Buffer.append(event.target.result)
+
+    if (!this.readNextChunk()) {
+      const binaryDigest = this.md5Buffer.end(true)
+      const base64digest = btoa(binaryDigest)
+      this.callback(null, base64digest)
+    }
+  }
+
+  fileReaderDidError(event) {
+    this.callback(`Error reading ${this.file.name}`)
+  }
+
+  readNextChunk() {
+    if (this.chunkIndex < this.chunkCount || (this.chunkIndex == 0 && this.chunkCount == 0)) {
+      const start = this.chunkIndex * this.chunkSize
+      const end = Math.min(start + this.chunkSize, this.file.size)
+      const bytes = fileSlice.call(this.file, start, end)
+      this.fileReader.readAsArrayBuffer(bytes)
+      this.chunkIndex++
+      return true
+    } else {
+      return false
+    }
+  }
+}

data/app/javascript/tessa/index.js.coffee

@@ -0,0 +1,183 @@
+import {FileChecksum} from '../activestorage/file_checksum'
+
+window.WCC ||= {}
+$ = window.jQuery
+
+Dropzone.autoDiscover = off
+
+class window.WCC.Dropzone extends window.Dropzone
+
+  uploadFile: (file) ->
+    xhr = new XMLHttpRequest
+    file.xhr = xhr
+
+    # Set in our custom accept method
+    xhr.open file.uploadMethod, file.uploadURL, true
+    xhr.setRequestHeader headerName, headerValue for headerName, headerValue of file.uploadHeaders
+
+    response = null
+
+    handleError = =>
+      @_errorProcessing [file], response || @options.dictResponseError.replace("{{statusCode}}", xhr.status), xhr
+
+    updateProgress = (e) =>
+      if e?
+        progress = 100 * e.loaded / e.total
+
+        file.upload =
+          progress: progress
+          total: e.total
+          bytesSent: e.loaded
+      else
+        # Called when the file finished uploading
+
+        allFilesFinished = yes
+
+        progress = 100
+
+        allFilesFinished = no unless file.upload.progress == 100 and file.upload.bytesSent == file.upload.total
+        file.upload.progress = progress
+        file.upload.bytesSent = file.upload.total
+
+        # Nothing to do, all files already at 100%
+        return if allFilesFinished
+
+      @emit "uploadprogress", file, progress, file.upload.bytesSent
+
+    xhr.onload = (e) =>
+      return if file.status == WCC.Dropzone.CANCELED
+      return unless xhr.readyState is 4
+
+      response = xhr.responseText
+
+      if xhr.getResponseHeader("content-type") and ~xhr.getResponseHeader("content-type").indexOf "application/json"
+        try
+          response = JSON.parse response
+        catch e
+          response = "Invalid JSON response from server."
+
+      updateProgress()
+
+      unless 200 <= xhr.status < 300
+        handleError()
+      else
+        @_finished [file], response, e
+
+    xhr.onerror = =>
+      return if file.status == WCC.Dropzone.CANCELED
+      handleError()
+
+    # Some browsers do not have the .upload property
+    progressObj = xhr.upload ? xhr
+    progressObj.onprogress = updateProgress
+
+    headers =
+      "Accept": "application/json",
+      "Cache-Control": "no-cache",
+      "X-Requested-With": "XMLHttpRequest",
+
+    extend headers, @options.headers if @options.headers
+
+    xhr.setRequestHeader headerName, headerValue for headerName, headerValue of headers
+
+    @emit "sending", file, xhr
+
+    xhr.send file
+
+  uploadFiles: (files) ->
+    @uploadFile(file) for file in files
+
+WCC.Dropzone.uploadPendingWarning =
+  "File uploads have not yet completed. If you submit the form now they will
+  not be saved. Are you sure you want to continue?"
+
+WCC.Dropzone.prototype.defaultOptions.url = "UNUSED"
+
+WCC.Dropzone.prototype.defaultOptions.dictDefaultMessage = "Drop files or click to upload."
+
+WCC.Dropzone.prototype.defaultOptions.accept = (file, done) ->
+  dz = $(file._removeLink).closest('.tessa-upload').first()
+  tessaParams = dz.data('tessa-params') or {}
+
+  postData =
+    name: file.name
+    size: file.size
+    mime_type: file.type
+
+  postData = $.extend postData, tessaParams
+
+  FileChecksum.create file, (error, checksum) ->
+    return done(error) if error
+
+    postData['checksum'] = checksum
+
+    $.ajax '/tessa/uploads',
+      type: 'POST',
+      data: postData,
+      success: (response) ->
+        file.uploadURL = response.upload_url
+        file.uploadMethod = response.upload_method
+        file.uploadHeaders = response.upload_headers
+        file.assetID = response.asset_id
+        done()
+      error: (response) ->
+        done("Failed to initiate the upload process!")
+
+window.WCC.tessaInit = (sel) ->
+  sel = sel || 'form:has(.tessa-upload)'
+  $(sel).each (i, form) ->
+    $form = $(form)
+    $form.bind 'submit', (event) ->
+      safeToSubmit = true
+      $form.find('.tessa-upload').each (j, dropzoneElement) ->
+        $(dropzoneElement.dropzone.files).each (k, file) ->
+          if file.status? and (file.status != WCC.Dropzone.SUCCESS)
+            safeToSubmit = false
+      if not safeToSubmit and not confirm(WCC.Dropzone.uploadPendingWarning)
+        return false
+
+  $('.tessa-upload', sel).each (i, item) ->
+    $item = $(item)
+    args =
+      maxFiles: 1
+      addRemoveLinks: true
+
+    $.extend args, $item.data("dropzone-options")
+    args.maxFiles = null if $item.hasClass("multiple")
+    inputPrefix = $item.data("asset-field-prefix")
+
+    dropzone = new WCC.Dropzone item, args
+
+    $item.find('input[type="hidden"]').each (j, input) ->
+      $input = $(input)
+      mockFile = $input.data("meta")
+      mockFile.accepted = true
+      dropzone.options.addedfile.call(dropzone, mockFile)
+      dropzone.options.thumbnail.call(dropzone, mockFile, mockFile.url)
+      dropzone.emit("complete", mockFile)
+      dropzone.files.push mockFile
+
+    updateAction = (file) ->
+      return unless file.assetID?
+      inputID = "#tessa_asset_action_#{file.assetID}"
+      actionInput = $(inputID)
+      unless actionInput.length
+        actionInput = $('<input type="hidden">')
+          .attr
+            id: inputID
+            name: "#{inputPrefix}[#{file.assetID}][action]"
+          .appendTo item
+
+      actionInput.val file.action
+
+    dropzone.on 'success', (file) ->
+      file.action = "add"
+      updateAction(file)
+
+    dropzone.on 'removedfile', (file) ->
+      file.action = "remove"
+      updateAction(file)
+
+
+$ ->
+  window.WCC.tessaInit()

data/config/routes.rb

@@ -0,0 +1,3 @@
+Tessa::Engine.routes.draw do
+  post '/tessa/uploads', to: Tessa::RackUploadProxy
+end

data/lib/tessa/active_storage/asset_wrapper.rb

@@ -0,0 +1,24 @@
+module Tessa::ActiveStorage
+  class AssetWrapper < SimpleDelegator
+    def public_url
+      Rails.application.routes.url_helpers.
+        rails_blob_url(__getobj__, disposition: :inline)
+    end
+
+    def private_url(expires_in: 1.day)
+      service_url(disposition: :inline, expires_in: expires_in)
+    end
+
+    def private_download_url(expires_in: 1.day)
+      service_url(disposition: 'attachment', expires_in: expires_in)
+    end
+
+    def meta
+      {}
+    end
+
+    def failure?
+      false
+    end
+  end
+end

data/lib/tessa/engine.rb

@@ -0,0 +1,5 @@
+module Tessa
+  class Engine < Rails::Engine
+    isolate_namespace Tessa
+  end
+end

data/lib/tessa/model/dynamic_extensions.rb

@@ -0,0 +1,151 @@
+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.each do |change|
+                a.attach(change.id) if change.add?
+                a.detach if change.remove?
+              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}
+            })
+          end
+        CODE
+      mod
+    end
+  end
+
+  class MultipleRecord < ::Tessa::DynamicExtensions
+    def build(mod)
+      mod.class_eval <<~CODE, __FILE__, __LINE__ + 1
+          def #{name}
+            if #{name}_attachments.present?
+              return #{name}_attachments.map do |a|
+                Tessa::ActiveStorage::AssetWrapper.new(a)
+              end
+            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}_attachments.map(&:key) if #{name}_attachments.present?
+
+            # fallback to 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.each do |change|
+                a.attach(change.id) if change.add?
+                raise 'TODO' if change.remove?
+              end
+            when nil
+              a.detach
+            else
+              a.attach(*attachables)
+            end
+
+            # overwrite the tessa ID in the database
+            self.#{field.id_field} = nil
+          end
+
+          def attributes
+            super.merge({
+              '#{field.id_field}' => #{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.rb

@@ -1,4 +1,6 @@
 require 'tessa/model/field'
+require 'tessa/model/dynamic_extensions'
+require 'tessa/active_storage/asset_wrapper'
 
 module Tessa
   module Model
@@ -33,19 +35,7 @@ module Tessa
       end
 
       def fetch_tessa_remote_assets(ids)
-        if [*ids].empty?
-          [] if ids.is_a?(Array)
-        else
-          Tessa::Asset.find(ids)
-        end
-      rescue Tessa::RequestFailed => err
-        if ids.is_a?(Array)
-          ids.map do |id|
-            Tessa::Asset::Failure.factory(id: id, response: err.response)
-          end
-        else
-          Tessa::Asset::Failure.factory(id: ids, response: err.response)
-        end
+        Tessa.find_assets(ids)
       end
 
       private def reapplying_asset?(field, change_set)
@@ -61,37 +51,38 @@ module Tessa
     module ClassMethods
       def asset(name, args={})
         field = tessa_fields[name] = Field.new(args.merge(name: name))
+        
+        multiple = args[:multiple]
 
-        dynamic_extensions = Module.new
 
-        dynamic_extensions.send(:define_method, name) do
-          if instance_variable_defined?(ivar = "@#{name}")
-            instance_variable_get(ivar)
+        if respond_to?(:has_one_attached)
+          if multiple
+            has_many_attached(name)
           else
-            instance_variable_set(
-              ivar,
-              fetch_tessa_remote_assets(field.id(on: self))
-            )
+            has_one_attached(name)
           end
         end
 
-        dynamic_extensions.send(:define_method, "#{name}=") do |value|
-          change_set = field.change_set_for(value)
-
-          # should effectively cause a no-op
-          return if reapplying_asset?(field, change_set)
-
-          if !(field.multiple? && value.is_a?(AssetChangeSet))
-            new_ids = change_set.scoped_changes.select(&:add?).map(&:id)
-            change_set += field.difference_change_set(new_ids, on: self)
+        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)
 
-          pending_tessa_change_sets[name] += change_set
-
-          field.apply(change_set, on: self)
-        end
-
-        include dynamic_extensions
+        # 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

data/lib/tessa/rack_upload_proxy.rb

@@ -2,26 +2,34 @@ 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']
-      upload = Tessa::Upload.create({
-        name: params["name"],
-        size: params["size"],
-        date: params["date"],
-        mime_type: params["mime_type"],
-      }.reject { |k, v| v.nil? })
+
+      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] << upload.asset_id
+      env['rack.session'][:tessa_upload_asset_ids] << blob.signed_id
 
       response = {
-        asset_id: upload.asset_id,
-        upload_url: upload.upload_url,
-        upload_method: upload.upload_method,
+        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)

data/lib/tessa/version.rb

@@ -1,3 +1,3 @@
 module Tessa
-  VERSION = "0.9.2"
+  VERSION = "1.0.0-rc1"
 end

data/lib/tessa/view_helpers.rb

@@ -1,8 +1,10 @@
 module Tessa
   module ViewHelpers
-    def tessa_image_tag(asset)
+    def tessa_image_tag(asset, private: false)
       handle_asset_failure(asset) do
-        image_tag(asset.private_url)
+        image_tag(
+          private ? asset.private_url : asset.public_url
+        )
       end
     end
 

data/lib/tessa.rb

@@ -24,6 +24,32 @@ module Tessa
     yield config
   end
 
+  def self.find_assets(ids)
+    if [*ids].empty?
+      if ids.is_a?(Array)
+        []
+      else
+        nil
+      end
+    elsif (blobs = ::ActiveStorage::Blob.where(key: ids).to_a).present?
+      if ids.is_a?(Array)
+        blobs.map { |a| Tessa::ActiveStorage::AssetWrapper.new(a) }
+      else
+        Tessa::ActiveStorage::AssetWrapper.new(blobs.first)
+      end
+    else
+      Tessa::Asset.find(ids)
+    end
+  rescue Tessa::RequestFailed => err
+    if ids.is_a?(Array)
+      ids.map do |id|
+        Tessa::Asset::Failure.factory(id: id, response: err.response)
+      end
+    else
+      Tessa::Asset::Failure.factory(id: ids, response: err.response)
+    end
+  end
+
   class RequestFailed < StandardError
     attr_reader :response
 
@@ -34,3 +60,7 @@ module Tessa
   end
 
 end
+
+if defined?(Rails::Railtie)
+  require "tessa/engine"
+end

data/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@watermarkchurch/tessa",
+  "version": "2.0.0",
+  "description": "Attach cloud and local files in Rails applications",
+  "module": "app/assets/javascripts/tessa.esm.js",
+  "main": "app/assets/javascripts/tessa.js",
+  "files": [
+    "app/assets/javascripts/*.js",
+    "src/*.js"
+  ],
+  "homepage": "https://www.watermark.org/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/watermarkchurch/tessa-client.git"
+  },
+  "bugs": {
+    "url": "https://github.com/watermarkchurch/tessa-client/issues"
+  },
+  "author": "Watermark Dev <dev@watermark.org>",
+  "license": "MIT",
+  "dependencies": {
+    "spark-md5": "^3.0.1"
+  },
+  "peerDependencies": {
+    "dropzone": ">= 4"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^19.0.1",
+    "@rollup/plugin-node-resolve": "^11.0.1",
+    "coffeescript": "^2.7.0",
+    "eslint": "^4.3.0",
+    "eslint-plugin-import": "^2.23.4",
+    "rollup": "^2.35.1",
+    "rollup-plugin-coffee-script": "^2.0.0",
+    "rollup-plugin-terser": "^7.0.2"
+  },
+  "scripts": {
+    "prebuild": "yarn lint",
+    "build": "rollup --config rollup.config.js",
+    "lint": "eslint app/javascript",
+    "prepublishOnly": "rm -rf src && cp -R app/javascript/activestorage src"
+  }
+}