attachie 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9fce9a92b9b729e8d2a453178293afaf74b1658321cdbc81d4d0ec5fd95794d8
+  data.tar.gz: 3bab92b185f8d97105155c686c87153f81cb994242df9b848c30601a830283a0
+SHA512:
+  metadata.gz: 1548848d991986d9bb32442dfe5fa5cc1c55822aa6b6e5e47f5fa7004a222cd5840cd4bac172d631c0c2085bef5eeeaeb98476f24340bde131ec244d2a068e7d
+  data.tar.gz: d3ca7add377253d86228affb874d839720c3275b8005322b84c36eab65ad517aed7d10f62a694165ca536d0ca54341d35ab9911bc7284a7beb17bc730ca93eb7

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,13 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.3
+addons:
+  hosts:
+    - bucket.localhost
+before_install:
+  - docker-compose up -d
+  - sleep 10
+install:
+  - travis_retry bundle install
+script: rspec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in attachments.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Benjamin Vetter
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,103 @@
+# Attachie
+
+[![Build Status](https://secure.travis-ci.org/mrkamel/attachie.png?branch=master)](http://travis-ci.org/mrkamel/attachie)
+
+Declarative and flexible attachments.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'attachie'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install attachie
+
+## Usage
+
+First, `include Attachie` and specify an attachment:
+
+```ruby
+class User
+  include Attachie
+
+  attachment :avatar, versions: {
+    icon: { path: "users/:id/avatar/icon.jpg" },
+    thumbnail: { path: "users/:id/avatar/thumbnail.jpg" },
+    original: { path: "users/:id/avatar/original.jpg" }
+  }
+end
+```
+
+Second, store blobs for your version:
+
+```ruby
+user.avatar(:icon).store("blob")
+user.avatar(:thumbnail).store("blob")
+user.avatar(:original).store("blob")
+```
+
+or via multipart upload
+
+```ruby
+user.avatar(:icon).store_multipart do |upload|
+  upload.upload_part "chunk1"
+  upload.upload_part "chunk2"
+  # ...
+end
+```
+
+Third, add the images url to your views:
+
+```
+image_tag user.avatar(:thumbnail).url
+```
+
+More methods to manipulate the blobs:
+
+```ruby
+user.avatar(:icon).delete
+user.avatar(:icon).exists?
+user.avatar(:icon).value
+user.avatar(:icon).temp_url(expires_in: 2.days) # Must be supported by the driver
+```
+
+## Drivers
+
+The `attachie` gem ships with the following drivers:
+
+* `Attachie::FileDriver`: To store files on the local file system
+* `Attachie::FakeDriver`: To store files in memory (for testing)
+* `Attachie::S3Driver`: To store files on S3
+* `Attachie::SwiftDriver`: To store files on an Openstack Swift provider
+
+You can eg use the file system driver:
+
+```ruby
+require "attachie/file_driver"
+
+Attachie.default_options[:driver] = Attachie::FileDriver.new("/path/to/attachments")
+
+class User
+  include Attachie
+
+  attachment :avatar, host: "www.example.com", versions: {
+    # ...
+  }
+end
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/mrkamel/attachie/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/attachie.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'attachie/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "attachie"
+  spec.version       = Attachie::VERSION
+  spec.authors       = ["Benjamin Vetter"]
+  spec.email         = ["vetter@plainpicture.de"]
+  spec.summary       = %q{Declarative and flexible attachments}
+  spec.description   = %q{Declarative and flexible attachments}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "swift_client"
+  spec.add_dependency "aws-sdk-s3"
+  spec.add_dependency "mime-types"
+  spec.add_dependency "connection_pool"
+  spec.add_dependency "activesupport"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "fakes3"
+end

data/docker-compose.yml

@@ -0,0 +1,9 @@
+
+version: '2'
+
+services:
+  fakes3:
+    image: lphoward/fake-s3
+    ports:
+      - 4569:4569
+

data/lib/attachie.rb

@@ -0,0 +1,172 @@
+
+require "attachie/version"
+require "attachie/interpolation"
+require "active_support/all"
+
+module Attachie
+  class UnknownAttachment < StandardError; end
+  class NoSuchVersion < StandardError; end
+  class InterpolationError < StandardError; end
+
+  def self.default_options
+    @default_options ||= { :protocol => "http" }
+  end
+
+  class Attachment
+    class Version
+      attr_accessor :attachment, :name, :options
+
+      def initialize(attachment, name, options)
+        self.attachment = attachment
+        self.name = name
+        self.options = options
+      end
+
+      def url
+        "#{interpolate option(:protocol)}://#{interpolate option(:host)}/#{interpolate(option(:url_prefix)).to_s + "/" if option(:url_prefix)}#{path}#{interpolate(option(:url_suffix)) if option(:url_suffix)}"
+      end
+
+      def path
+        "#{interpolate(option(:path_prefix)) + "/" if option(:path_prefix)}#{path_without_prefix}"
+      end
+
+      def path_without_prefix
+        interpolate option(:path)
+      end
+
+      def container
+        interpolate option(:container) || option(:bucket)
+      end
+
+      alias_method :bucket, :container
+
+      def temp_url(opts = {})
+        return url unless option(:driver).respond_to?(:temp_url)
+
+        option(:driver).temp_url(path, container, opts)
+      end
+
+      def value
+        option(:driver).value(path, container)
+      end
+
+      def store(data_or_io, opts = {})
+        option(:driver).store(path, data_or_io, container, opts)
+      end
+
+      def store_multipart(opts = {}, &block)
+        option(:driver).store_multipart(path, container, opts, &block)
+      end
+
+      def delete
+        option(:driver).delete(path, container)
+      end
+
+      def exists?
+        option(:driver).exists?(path, container)
+      end
+
+      def inspect
+        to_s
+      end
+
+      def object
+        attachment.object
+      end
+
+      def method_missing(method_name, *args, &block)
+        return attachment.options[:versions][name][method_name.to_sym] if attachment.options[:versions][name].key?(method_name.to_sym)
+
+        super
+      end
+
+      def respond_to_missing?(method_name, *args)
+        attachment.options[:versions][name].key?(method_name.to_sym)
+      end
+
+      private
+
+      def option(option_name)
+        return attachment.options[:versions][name][option_name] if attachment.options[:versions][name].key?(option_name)
+        return options[option_name] if options.key?(option_name)
+        return attachment.options[option_name] if attachment.options.key?(option_name)
+
+        Attachie.default_options[option_name]
+      end
+
+      def interpolate(str)
+        raise(InterpolationError) unless str.is_a?(String)
+
+        str.gsub(/(?<!\\):[a-zA-Z][a-zA-Z0-9_]*/) do |attribute_name|
+          Interpolation.new(self).send(attribute_name.gsub(/^:/, ""))
+        end
+      end
+    end
+
+    attr_accessor :object, :name, :options
+
+    def initialize(object, name, options)
+      self.object = object
+      self.name = name
+      self.options = options
+    end
+
+    def version(version_name, opts = {})
+      raise(NoSuchVersion, "No such version: #{version_name}") unless options[:versions][version_name]
+
+      Version.new self, version_name, opts
+    end
+
+    def versions
+      options[:versions].collect { |version_name, _| version version_name }
+    end
+
+    def method_missing(method_name, *args, &block)
+      return options[method_name.to_sym] if options.key?(method_name.to_sym)
+
+      super
+    end
+
+    def respond_to_missing?(method_name, *args)
+      options.key?(method_name.to_sym)
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  def self.included(base)
+    base.class_attribute :attachments
+    base.attachments = {}
+
+    base.extend ClassMethods
+  end
+
+  def attachment(name)
+    definition = self.class.attachments[name]
+
+    raise(UnknownAttachment) unless definition
+
+    Attachment.new self, name, definition
+  end
+
+  module ClassMethods
+    def attachment(name, options = {})
+      self.attachments = attachments.merge(name => options)
+
+      define_method name do |version = nil, options = {}|
+        return instance_variable_get("@#{name}") if version.nil?
+
+        attachment(name).version(version, options)
+      end
+
+      define_method "#{name}=" do |value|
+        self.updated_at = Time.now if respond_to?(:updated_at=) && !value.nil?
+
+        instance_variable_set "@#{name}", value
+      end
+    end
+  end
+end
+

data/lib/attachie/fake_driver.rb

@@ -0,0 +1,83 @@
+
+module Attachie
+  class FakeMultipartUpload
+    include MonitorMixin
+
+    def initialize(name, bucket, options, &block)
+      super()
+
+      @name = name
+      @bucket = bucket
+
+      block.call(self) if block_given?
+    end
+
+    def upload_part(data)
+      synchronize do
+        @data ||= ""
+        @data << data
+      end
+
+      true
+    end
+
+    def data
+      synchronize do
+        @data
+      end
+    end
+
+    def abort_upload; end
+    def complete_upload; end
+  end
+
+  class FakeDriver
+    class ItemNotFound < StandardError; end
+
+    def list(bucket, prefix: nil)
+      return enum_for(:list, bucket, prefix: prefix) unless block_given?
+
+      objects(bucket).each do |key, _|
+        yield key if prefix.nil? || key.start_with?(prefix)
+      end
+    end
+
+    def store(name, data_or_io, bucket, options = {})
+      objects(bucket)[name] = data_or_io.respond_to?(:read) ? data_or_io.read : data_or_io
+    end 
+
+    def store_multipart(name, bucket, options = {}, &block)
+      objects(bucket)[name] = FakeMultipartUpload.new(name, bucket, options, &block).data
+    end
+
+    def exists?(name, bucket)
+      objects(bucket).key?(name)
+    end 
+
+    def delete(name, bucket)
+      objects(bucket).delete(name)
+    end 
+
+    def value(name, bucket)
+      raise(ItemNotFound) unless objects(bucket).key?(name)
+
+      objects(bucket)[name]
+    end 
+
+    def temp_url(name, bucket, options = {})
+      "https://example.com/#{bucket}/#{name}?signature=signature&expires=expires"
+    end
+
+    def flush
+      @objects = {}
+    end 
+
+    private
+
+    def objects(bucket)
+      @objects ||= {}
+      @objects[bucket] ||= {}
+    end 
+  end 
+end
+

data/lib/attachie/file_driver.rb

@@ -0,0 +1,109 @@
+
+require "fileutils"
+
+module Attachie
+  class FileDriver
+    class FileMultipartUpload
+      include MonitorMixin
+
+      def initialize(name, bucket, driver, &block)
+        super()
+
+        @name = name
+        @bucket = bucket
+        @driver = driver
+
+        @stream = open(driver.path_for(name, bucket), "wb")
+
+        if block_given?
+          begin
+            block.call(self)
+          rescue => e
+            abort_upload
+
+            raise e
+          end
+
+          complete_upload
+        end
+      end
+
+      def upload_part(data)
+        synchronize do
+          @stream.write(data)
+        end
+      end
+
+      def abort_upload
+        @stream.close
+
+        @target.delete(name, bucket)
+      end
+
+      def complete_upload
+        @stream.close
+      end
+    end
+
+    def initialize(base_path)
+      @base_path = base_path
+    end
+
+    def store(name, data_or_io, bucket, options = {})
+      path = path_for(name, bucket)
+
+      FileUtils.mkdir_p File.dirname(path)
+
+      open(path, "wb") do |stream|
+        io = data_or_io.respond_to?(:read) ? data_or_io : StringIO.new(data_or_io)
+
+        while chunk = io.read(1024)
+          stream.write chunk
+        end
+      end
+
+      true
+    end
+
+    def store_multipart(name, bucket, options = {}, &block)
+      path = path_for(name, bucket)
+
+      FileUtils.mkdir_p File.dirname(path)
+
+      FileMultipartUpload.new(name, bucket, self, &block)
+    end
+
+    def value(name, bucket)
+      File.binread path_for(name, bucket)
+    end
+
+    def delete(name, bucket)
+      path = path_for(name, bucket)
+
+      FileUtils.rm_f(path)
+
+      begin
+        dir = File.dirname(File.join(bucket, name))
+
+        until dir == bucket
+          Dir.rmdir File.join(@base_path, dir)
+
+          dir = File.dirname(dir)
+        end
+      rescue Errno::ENOTEMPTY, Errno::ENOENT
+        # nothing
+      end
+
+      true
+    end
+
+    def exists?(name, bucket)
+      File.exists? path_for(name, bucket)
+    end
+
+    def path_for(name, bucket)
+      File.join(@base_path, bucket, name)
+    end
+  end
+end
+

data/lib/attachie/interpolation.rb

@@ -0,0 +1,25 @@
+
+module Attachie
+  class Interpolation
+    attr_accessor :version
+
+    def initialize(version)
+      self.version = version
+    end
+
+    def container
+      version.container
+    end
+
+    alias_method :bucket, :container
+
+    def method_missing(name, *args, &block)
+      version.object.send name
+    end
+
+    def respond_to?(name, *args)
+      super(name, *args) || version.object.respond_to?(name, *args)
+    end
+  end
+end
+

data/lib/attachie/s3_driver.rb

@@ -0,0 +1,119 @@
+
+require "aws-sdk-s3"
+require "mime-types"
+
+module Attachie
+  class S3MultipartUpload
+    include MonitorMixin
+
+    def initialize(s3_client, name, bucket, options, &block)
+      super()
+
+      @s3_client = s3_client
+      @bucket = bucket
+      @name = name
+
+      @parts = []
+
+      @upload_id = @s3_client.create_multipart_upload(options.merge(bucket: bucket, key: name)).to_h[:upload_id]
+
+      if block_given?
+        begin
+          block.call(self)
+        rescue => e
+          abort_upload
+
+          raise e
+        end
+
+        complete_upload
+      end
+    end
+
+    def upload_part(data)
+      index = synchronize do
+        part_number = @parts.size + 1
+
+        @parts << { part_number: part_number, etag: "\"#{Digest::MD5.hexdigest(data)}\"" }
+
+        part_number
+      end
+
+      @s3_client.upload_part(body: data, bucket: @bucket, key: @name, upload_id: @upload_id, part_number: index)
+    end
+
+    def abort_upload
+      @s3_client.abort_multipart_upload(bucket: @bucket, key: @name, upload_id: @upload_id)
+    end
+
+    def complete_upload
+      @s3_client.complete_multipart_upload(bucket: @bucket, key: @name, upload_id: @upload_id, multipart_upload: { parts: @parts })
+    end
+  end
+
+  class S3Driver
+    attr_accessor :s3_client, :s3_resource
+
+    def initialize(s3_client)
+      self.s3_client = s3_client
+      self.s3_resource = Aws::S3::Resource.new(client: s3_client)
+    end
+
+    def list(bucket, prefix: nil)
+      return enum_for(:list, bucket, prefix: prefix) unless block_given?
+
+      options = {}
+      options[:prefix] = prefix if prefix
+
+      s3_resource.bucket(bucket).objects(options).each do |object|
+        yield object.key
+      end
+    end
+
+    def store(name, data_or_io, bucket, options = {})
+      opts = options.dup
+
+      mime_type = MIME::Types.of(name).first
+
+      opts[:content_type] ||= mime_type.content_type if mime_type
+      opts[:content_type] ||= "application/octet-stream"
+
+      opts[:body] = data_or_io
+
+      s3_resource.bucket(bucket).object(name).put(opts)
+    end
+
+    def store_multipart(name, bucket, options = {}, &block)
+      opts = options.dup
+
+      mime_type = MIME::Types.of(name).first
+
+      opts[:content_type] ||= mime_type.content_type if mime_type
+      opts[:content_type] ||= "application/octet-stream"
+
+      S3MultipartUpload.new(s3_client, name, bucket, opts, &block)
+    end
+
+    def value(name, bucket)
+      s3_resource.bucket(bucket).object(name).get.body.read.force_encoding(Encoding::BINARY)
+    end
+
+    def delete(name, bucket)
+      s3_resource.bucket(bucket).object(name).delete
+    end
+
+    def exists?(name, bucket)
+      s3_resource.bucket(bucket).object(name).exists?
+    end
+
+    def temp_url(name, bucket, options = {})
+      opts = options.dup
+      opts[:expires_in] = opts.delete(:expires_in).to_i if opts.key?(:expires_in)
+
+      method = opts.delete(:method) || :get
+
+      s3_resource.bucket(bucket).object(name).presigned_url(method, opts)
+    end
+  end
+end
+

data/lib/attachie/swift_driver.rb

@@ -0,0 +1,66 @@
+
+require "swift_client"
+require "connection_pool"
+
+module Attachie
+  class SwiftDriver
+    attr_accessor :swift_client_pool
+
+    def initialize(swift_client_pool)
+      self.swift_client_pool = swift_client_pool
+    end
+
+    def list(container, prefix: nil)
+      return enum_for(:list, container, prefix: prefix) unless block_given?
+
+      swift_client_pool.with do |swift_client|
+        swift_client.paginate_objects(container, prefix: prefix) do |response|
+          response.parsed_response.each do |source_object|
+            yield source_object["name"]
+          end
+        end
+      end
+    end
+
+    def store(name, data_or_io, container, headers = {})
+      swift_client_pool.with do |swift_client|
+        swift_client.put_object name, data_or_io, container, headers
+      end
+    end 
+
+    def value(name, container)
+      swift_client_pool.with do |swift_client|
+        swift_client.get_object(name, container).body
+      end
+    end 
+
+    def delete(name, container)
+      swift_client_pool.with do |swift_client|
+        swift_client.delete_object name, container
+      end
+    rescue SwiftClient::ResponseError => e
+      return true if e.code == 404
+
+      raise e
+    end 
+
+    def exists?(name, container)
+      swift_client_pool.with do |swift_client|
+        swift_client.head_object name, container
+      end
+
+      true
+    rescue SwiftClient::ResponseError => e
+      return false if e.code == 404
+
+      raise e
+    end 
+
+    def temp_url(name, container, options = {})
+      swift_client_pool.with do |swift_client|
+        swift_client.temp_url name, container, options
+      end
+    end
+  end
+end
+

data/lib/attachie/version.rb

@@ -0,0 +1,3 @@
+module Attachie
+  VERSION = "0.0.1"
+end

data/spec/attachie/fake_driver_spec.rb

@@ -0,0 +1,61 @@
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+RSpec.describe Attachie::FakeDriver do
+  let(:driver) { Attachie::FakeDriver.new }
+
+  it "should list objects" do
+    begin
+      driver.store("object1", "blob", "bucket1")
+      driver.store("object2", "blob", "bucket1")
+      driver.store("other", "blob", "bucket1")
+      driver.store("object", "blob", "bucket3")
+
+      expect(driver.list("bucket1", prefix: "object").to_a).to eq(["object1", "object2"])
+    ensure
+      driver.flush
+    end
+  end
+
+  it "should store a blob" do
+    begin
+      driver.store("name", "blob", "bucket")
+
+      expect(driver.exists?("name", "bucket")).to be(true)
+      expect(driver.value("name", "bucket")).to eq("blob")
+    ensure
+      driver.flush
+    end
+  end
+
+  it "should store a blob via multipart upload" do
+    begin
+      driver.store_multipart("name", "bucket") do |upload|
+        upload.upload_part("chunk1")
+        upload.upload_part("chunk2")
+      end
+
+      expect(driver.exists?("name", "bucket")).to be(true)
+      expect(driver.value("name", "bucket")).to eq("chunk1chunk2")
+    ensure
+      driver.flush
+    end
+  end
+
+  it "should delete a blob" do
+    begin
+      driver.store("name", "blob", "bucket")
+      expect(driver.exists?("name", "bucket")).to be(true)
+
+      driver.delete("name", "bucket")
+      expect(driver.exists?("name", "bucket")).to be(false)
+    ensure
+      driver.flush
+    end
+  end
+
+  it "should generate a temp_url" do
+    expect(driver.temp_url("name", "bucket")).to eq("https://example.com/bucket/name?signature=signature&expires=expires")
+  end
+end
+

data/spec/attachie/file_driver_spec.rb

@@ -0,0 +1,44 @@
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+RSpec.describe Attachie::FileDriver do
+  let(:driver) { Attachie::FileDriver.new("/tmp/attachie") }
+
+  it "should store a blob" do
+    begin
+      driver.store("name", "blob", "bucket")
+
+      expect(driver.exists?("name", "bucket")).to be(true)
+      expect(driver.value("name", "bucket")).to eq("blob")
+    ensure
+      driver.delete("name", "bucket")
+    end
+  end
+
+  it "should store a blob via multipart upload" do
+    begin
+      driver.store_multipart("name", "bucket") do |upload|
+        upload.upload_part("chunk1")
+        upload.upload_part("chunk2")
+      end
+
+      expect(driver.exists?("name", "bucket")).to be(true)
+      expect(driver.value("name", "bucket")).to eq("chunk1chunk2")
+    ensure
+      driver.delete("name", "bucket")
+    end
+  end
+
+  it "should delete a blob" do
+    begin
+      driver.store("name", "blob", "bucket")
+      expect(driver.exists?("name", "bucket")).to be(true)
+
+      driver.delete("name", "bucket")
+      expect(driver.exists?("name", "bucket")).to be(false)
+    ensure
+      driver.delete("name", "bucket")
+    end
+  end
+end
+

data/spec/attachie/s3_driver_spec.rb

@@ -0,0 +1,69 @@
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+RSpec.describe Attachie::S3Driver do
+  let(:driver) do
+    Attachie::S3Driver.new(Aws::S3::Client.new(
+      access_key_id: "access_key_id",
+      secret_access_key: "secret_access_key",
+      endpoint: "http://localhost:4569",
+      region: "us-east-1"
+    ))
+  end
+
+  it "should list objects" do
+    begin
+      driver.store("object1", "blob", "bucket")
+      driver.store("object2", "blob", "bucket")
+      driver.store("other", "blob", "bucket")
+
+      expect(driver.list("bucket", prefix: "object").to_a).to eq(["object1", "object2"])
+    ensure
+      driver.delete("object1", "bucket")
+      driver.delete("object2", "bucket")
+      driver.delete("other", "bucket")
+    end
+  end
+
+  it "should store a blob" do
+    begin
+      driver.store("name", "blob", "bucket")
+
+      expect(driver.exists?("name", "bucket")).to be(true)
+      expect(driver.value("name", "bucket")).to eq("blob")
+    ensure
+      driver.delete("name", "bucket")
+    end
+  end
+
+  it "should store a blob via multipart upload" do
+    begin
+      driver.store_multipart("name", "bucket") do |upload|
+        upload.upload_part("chunk1")
+        upload.upload_part("chunk2")
+      end
+
+      expect(driver.exists?("name", "bucket")).to be(true)
+      expect(driver.value("name", "bucket")).to eq("chunk1chunk2")
+    ensure
+      driver.delete("name", "bucket")
+    end
+  end
+
+  it "should delete a blob" do
+    begin
+      driver.store("name", "blob", "bucket")
+      expect(driver.exists?("name", "bucket")).to be(true)
+
+      driver.delete("name", "bucket")
+      expect(driver.exists?("name", "bucket")).to be(false)
+    ensure
+      driver.delete("name", "bucket")
+    end
+  end
+
+  it "should generate a temp_url" do
+    expect(driver.temp_url("name", "bucket")).to be_url
+  end
+end
+

data/spec/attachie/version_spec.rb

@@ -0,0 +1,60 @@
+
+require File.expand_path("../../spec_helper", __FILE__)
+
+RSpec.describe Attachie::Attachment::Version do
+  it "should interpolate the host, path_prefix and path" do
+    expect(Product.new(id: 1).image(:thumbnail).url).to eq("http://images.example.com/images/products/1/thumbnail.jpg")
+  end
+  
+  it "should know the path without prefix" do
+    expect(Product.new(id: 1).image(:thumbnail).path_without_prefix).to eq("products/1/thumbnail.jpg")
+  end
+
+  it "should know the bucket" do
+    expect(Product.new(id: 1).image(:thumbnail).bucket).to eq("images")
+  end
+
+  it "should store a blob" do
+    product = Product.new(id: 1)
+
+    begin
+      product.image(:thumbnail).store("blob")
+
+      expect(product.image(:thumbnail).exists?).to be(true)
+      expect(product.image(:thumbnail).value).to eq("blob")
+    ensure
+      product.image(:thumbnail).delete
+    end
+  end
+
+  it "should support multipart uploads" do
+    product = Product.new(id: 1)
+
+    begin
+      product.image(:thumbnail).store_multipart do |upload|
+        upload.upload_part("chunk1")
+        upload.upload_part("chunk2")
+      end
+
+      expect(product.image(:thumbnail).exists?).to be(true)
+      expect(product.image(:thumbnail).value).to eq("chunk1chunk2")
+    ensure
+      product.image(:thumbnail).delete
+    end
+  end
+
+  it "should delete a blob" do
+    product = Product.new(id: 1)
+
+    begin
+      product.image(:thumbnail).store("blob")
+      expect(product.image(:thumbnail).exists?).to be(true)
+
+      product.image(:thumbnail).delete
+      expect(product.image(:thumbnail).exists?).to be(false)
+    ensure
+      product.image(:thumbnail).delete
+    end
+  end
+end
+

data/spec/attachie_spec.rb

@@ -0,0 +1,57 @@
+
+require File.expand_path("../spec_helper", __FILE__)
+
+class TestModel
+  include Attachie
+
+  attachment :file, driver: Attachie::FakeDriver.new, bucket: "bucket", host: "www.example.com", versions: {
+    small: { path: "path/to/small/:filename", attribute: "value" },
+    large: { path: "path/to/large/:filename" }
+  }
+
+  attr_accessor :filename, :updated_at
+
+  def initialize(filename:)
+    self.filename = filename
+  end
+end
+
+RSpec.describe TestModel do
+  it "should interpolate the path" do
+    test_model = TestModel.new(filename: "file.jpg")
+
+    expect(test_model.file(:small).path).to eq("path/to/small/file.jpg")
+  end
+
+  it "should allow arbitrary version methods" do
+    test_model = TestModel.new(filename: "file.jpg")
+
+    expect(test_model.file(:small).attribute).to eq("value")
+  end
+
+  it "should espect the host" do
+    test_model = TestModel.new(filename: "file.jpg")
+
+    expect(test_model.file(:large).url).to eq("http://www.example.com/path/to/large/file.jpg")
+  end
+
+  it "should correctly use the driver" do
+    test_model = TestModel.new(filename: "blob.txt")
+    test_model.file(:large).store "blob"
+
+    expect(test_model.file(:large).value).to eq("blob")
+  end
+
+  it "should set updated_at" do
+    test_model = TestModel.new(filename: "file.jpg")
+    test_model.file = "file"
+
+    expect(test_model.updated_at).to_not be_nil
+
+    test_model = TestModel.new(filename: "file.jpg")
+    test_model.file = nil
+
+    expect(test_model.updated_at).to be_nil
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+
+require File.expand_path("../../lib/attachie", __FILE__)
+
+require "attachie/file_driver"
+require "attachie/fake_driver"
+require "attachie/s3_driver"
+
+class Product
+  include Attachie
+
+  attr_accessor :id
+
+  def initialize(attributes = {})
+    attributes.each do |key, value|
+      self.send("#{key}=", value)
+    end
+  end
+
+  attachment :image, host: ":subdomain.example.com", path_prefix: ":bucket", bucket: "images", driver: Attachie::FileDriver.new("/tmp/attachie"), versions: {
+    thumbnail: { path: "products/:id/thumbnail.jpg" },
+    original: { path: "products/:id/original.jpg" }
+  }
+
+  def subdomain
+    "images"
+  end
+end
+
+RSpec::Matchers.define :be_url do |expected|
+  match do |actual|
+    URI.parse(actual) rescue false
+  end
+end

metadata

@@ -0,0 +1,197 @@
+--- !ruby/object:Gem::Specification
+name: attachie
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Benjamin Vetter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: swift_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakes3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Declarative and flexible attachments
+email:
+- vetter@plainpicture.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- attachie.gemspec
+- docker-compose.yml
+- lib/attachie.rb
+- lib/attachie/fake_driver.rb
+- lib/attachie/file_driver.rb
+- lib/attachie/interpolation.rb
+- lib/attachie/s3_driver.rb
+- lib/attachie/swift_driver.rb
+- lib/attachie/version.rb
+- spec/attachie/fake_driver_spec.rb
+- spec/attachie/file_driver_spec.rb
+- spec/attachie/s3_driver_spec.rb
+- spec/attachie/version_spec.rb
+- spec/attachie_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Declarative and flexible attachments
+test_files:
+- spec/attachie/fake_driver_spec.rb
+- spec/attachie/file_driver_spec.rb
+- spec/attachie/s3_driver_spec.rb
+- spec/attachie/version_spec.rb
+- spec/attachie_spec.rb
+- spec/spec_helper.rb