saviour 0.2.0

data/lib/saviour/processors/digest.rb

@@ -0,0 +1,16 @@
+module Saviour
+  module Processors
+    module Digest
+      def digest_filename(contents, filename, opts = {})
+        separator = opts.fetch(:separator, "-")
+
+        digest = ::Digest::MD5.hexdigest(contents)
+        extension = ::File.extname(filename)
+
+        new_filename = "#{[::File.basename(filename, ".*"), digest].join(separator)}#{extension}"
+
+        [contents, new_filename]
+      end
+    end
+  end
+end

data/lib/saviour/s3_storage.rb

@@ -0,0 +1,77 @@
+module Saviour
+  class S3Storage
+    def initialize(conf = {})
+      @bucket = conf.delete(:bucket)
+      @public_url_prefix = conf.delete(:public_url_prefix)
+      @conf = conf
+      @overwrite_protection = conf.delete(:overwrite_protection) { true }
+      assert_directory_exists!
+    end
+
+    def write(contents, path)
+      raise(RuntimeError, "The path you're trying to write already exists!") if @overwrite_protection && exists?(path)
+
+      path = sanitize_leading_slash(path)
+      directory.files.create(
+          key: path,
+          body: contents,
+          public: true
+      )
+    end
+
+    def read(path)
+      path = sanitize_leading_slash(path)
+      assert_exists(path)
+      directory.files.get(path).body
+    end
+
+    def delete(path)
+      path = sanitize_leading_slash(path)
+      assert_exists(path)
+      directory.files.get(path).destroy
+    end
+
+    def exists?(path)
+      path = sanitize_leading_slash(path)
+      !!directory.files.head(path)
+    end
+
+    def public_url(path)
+      raise(RuntimeError, "You must provide a `public_url_prefix`") unless public_url_prefix
+
+      path = sanitize_leading_slash(path)
+      ::File.join(public_url_prefix, path)
+    end
+
+
+    private
+
+    def public_url_prefix
+      if @public_url_prefix.respond_to?(:call)
+        @public_url_prefix.call
+      else
+        @public_url_prefix
+      end
+    end
+
+    def sanitize_leading_slash(path)
+      path.gsub(/\A\/*/, '')
+    end
+
+    def assert_directory_exists!
+      directory || raise(ArgumentError, "The bucket #{@bucket} doesn't exists or misconfigured connection.")
+    end
+
+    def assert_exists(path)
+      raise RuntimeError, "File does not exists: #{path}" unless exists?(path)
+    end
+
+    def directory
+      @directory ||= connection.directories.get(@bucket)
+    end
+
+    def connection
+      @connection ||= Fog::Storage.new({provider: 'AWS'}.merge(@conf))
+    end
+  end
+end

data/lib/saviour/string_source.rb

@@ -0,0 +1,15 @@
+module Saviour
+  class StringSource
+    def initialize(value, filename = nil)
+      @value, @filename = value, filename
+    end
+
+    def read
+      @value
+    end
+
+    def original_filename
+      @filename
+    end
+  end
+end

data/lib/saviour/uploader/element.rb

@@ -0,0 +1,19 @@
+module Saviour
+  module Uploader
+    class Element
+      attr_reader :version, :method_or_block
+
+      def initialize(version, method_or_block)
+        @version, @method_or_block = version, method_or_block
+      end
+
+      def versioned?
+        !!@version
+      end
+
+      def block?
+        @method_or_block.respond_to?(:call)
+      end
+    end
+  end
+end

data/lib/saviour/uploader/processors_runner.rb

@@ -0,0 +1,88 @@
+module Saviour
+  module Uploader
+    class ProcessorsRunner
+      attr_writer :file
+      attr_accessor :contents
+      attr_accessor :filename
+
+      def initialize(uploader, version_name)
+        @uploader, @version_name = uploader, version_name
+      end
+
+      def matching_processors
+        @uploader.class.processors.select { |processor| !processor[:element].versioned? || processor[:element].version == @version_name }
+      end
+
+      def file
+        @file ||= Tempfile.new([SecureRandom.hex, ::File.extname(filename)]).tap { |x| x.binmode }
+      end
+
+      def run_element(element, opts, data)
+        if element.block?
+          @uploader.instance_exec(data, filename, &element.method_or_block)
+        else
+          if opts.empty?
+            @uploader.send(element.method_or_block, data, filename)
+          else
+            @uploader.send(element.method_or_block, data, filename, opts)
+          end
+        end
+      end
+
+      def advance!(processor, previous_type)
+        if processor[:type] != previous_type
+          if processor[:type] == :memory
+            self.contents = ::File.read(file)
+          else
+            file.rewind
+            file.write(contents)
+            file.flush
+            file.rewind
+          end
+        end
+      end
+
+      def run_processor(processor)
+        element = processor[:element]
+        opts = processor[:opts]
+
+        if processor[:type] == :memory
+          result = run_element(element, opts, contents)
+
+          self.contents = result[0]
+          self.filename = result[1]
+
+        else
+          file.rewind
+
+          result = run_element(element, opts, file)
+
+          self.file = result[0]
+          self.filename = result[1]
+        end
+      end
+
+      def run!(content_data, initial_filename)
+        self.contents = content_data
+        self.filename = initial_filename
+        previous_type = :memory
+
+        matching_processors.each do |processor|
+          advance!(processor, previous_type)
+
+          run_processor(processor)
+          previous_type = processor[:type]
+        end
+
+        if previous_type == :file
+          file.rewind
+          self.contents = ::File.read(file)
+        end
+
+        file.delete
+
+        [contents, filename]
+      end
+    end
+  end
+end

data/lib/saviour/uploader/store_dir_extractor.rb

@@ -0,0 +1,41 @@
+module Saviour
+  module Uploader
+    class StoreDirExtractor
+      def initialize(uploader)
+        @uploader = uploader
+      end
+
+      def candidate_store_dirs
+        @candidate_store_dirs ||= @uploader.class.store_dirs
+      end
+
+      def versioned_store_dirs?
+        candidate_store_dirs.any? { |x| x.versioned? && x.version == @uploader.version_name }
+      end
+
+      def versioned_store_dir
+        candidate_store_dirs.select { |x| x.versioned? && x.version == @uploader.version_name }.last if versioned_store_dirs?
+      end
+
+      def non_versioned_store_dir
+        candidate_store_dirs.select { |x| !x.versioned? }.last
+      end
+
+      def store_dir_handler
+        @store_dir_handler ||= versioned_store_dir || non_versioned_store_dir
+      end
+
+      def store_dir
+        @store_dir ||= begin
+          if store_dir_handler
+            if store_dir_handler.block?
+              @uploader.instance_eval(&store_dir_handler.method_or_block)
+            else
+              @uploader.send(store_dir_handler.method_or_block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/saviour/url_source.rb

@@ -0,0 +1,55 @@
+require 'uri'
+
+module Saviour
+  class UrlSource
+    MAX_REDIRECTS = 10
+
+    def initialize(url)
+      @uri = wrap_uri_string(url)
+    end
+
+    def read
+      with_retry(3) { resolve(@uri) }
+    end
+
+    def original_filename
+      ::File.basename(@uri.path)
+    end
+
+    def path
+      @uri.path
+    end
+
+
+    private
+
+    def resolve(uri, max_redirects = MAX_REDIRECTS)
+      raise RuntimeError, "Max number of allowed redirects reached (#{MAX_REDIRECTS}) when resolving #{@uri}" if max_redirects == 0
+
+      response = Net::HTTP.get_response(uri)
+
+      case response
+        when Net::HTTPSuccess
+          response.body
+        when Net::HTTPRedirection
+          resolve(wrap_uri_string(response['location']), max_redirects - 1)
+        else
+          false
+      end
+    end
+
+    def wrap_uri_string(url)
+      begin
+        URI(url)
+      rescue URI::InvalidURIError
+        raise ArgumentError, "'#{url}' is not a valid URI"
+      end
+    end
+
+    def with_retry(n = 3, &block)
+      raise(RuntimeError, "Connection to #{@uri} failed after 3 attempts.") if n == 0
+
+      block.call || with_retry(n - 1, &block)
+    end
+  end
+end

data/lib/saviour/version.rb

@@ -0,0 +1,3 @@
+module Saviour
+  VERSION = "0.2.0"
+end

data/saviour.gemspec

@@ -0,0 +1,26 @@
+require './lib/saviour/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "saviour"
+  spec.version       = Saviour::VERSION
+  spec.authors       = ["Roger Campos"]
+  spec.email         = ["roger@rogercampos.com"]
+  spec.description   = %q{File storage handler following active record model lifecycle}
+  spec.summary       = %q{File storage handler following active record model lifecycle}
+  spec.homepage      = "https://github.com/rogercampos/saviour"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.0.0"
+
+  spec.add_dependency "activerecord", ">= 3.0"
+  spec.add_dependency "activesupport", ">= 3.0"
+  spec.add_dependency "fog-aws"
+  spec.add_dependency "mime-types"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "sqlite3"
+end

data/spec/feature/access_to_model_and_mounted_as.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "access to model data from uploaders" do
+  before { Saviour::Config.storage = Saviour::LocalStorage.new(local_prefix: @tmpdir, public_url_prefix: "http://domain.com") }
+  after { Saviour::Config.storage = nil }
+
+  let(:uploader) {
+    Class.new(Saviour::BaseUploader) do
+      store_dir { "/store/dir/#{model.id}" }
+      process { |contents, name| [contents, "#{model.id}-#{attached_as}-#{name}"] }
+    end
+  }
+
+  let(:klass) {
+    a = Class.new(Text)
+    a.attach_file :file, uploader
+    a
+  }
+
+  describe "file store" do
+    it do
+      with_test_file("example.xml") do |example, name|
+        a = klass.create! id: 87
+        expect(a.update_attributes(file: example)).to be_truthy
+        expect(Saviour::Config.storage.exists?(a[:file])).to be_truthy
+        expect(a[:file]).to eq "/store/dir/87/87-file-#{name}"
+      end
+    end
+  end
+end

data/spec/feature/crud_workflows_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe "saving a new file" do
+  before { Saviour::Config.storage = Saviour::LocalStorage.new(local_prefix: @tmpdir, public_url_prefix: "http://domain.com") }
+  after { Saviour::Config.storage = nil }
+
+  let(:uploader) {
+    Class.new(Saviour::BaseUploader) {
+      store_dir { "/store/dir" }
+    }
+  }
+
+  let(:klass) {
+    a = Class.new(Test) { include Saviour }
+    a.attach_file :file, uploader
+    a
+  }
+
+  describe "creation" do
+    it do
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        expect(a.update_attributes(file: example)).to be_truthy
+      end
+    end
+
+    it do
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        a.update_attributes(file: example)
+
+        expect(Saviour::Config.storage.exists?(a[:file])).to be_truthy
+      end
+    end
+
+    it do
+      with_test_file("example.xml") do |example, real_filename|
+        a = klass.create!
+        a.update_attributes(file: example)
+        expect(a[:file]).to eq "/store/dir/#{real_filename}"
+      end
+    end
+
+    it do
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        a.update_attributes(file: example)
+
+        example.rewind
+        expect(a.file.read).to eq example.read
+      end
+    end
+
+    it do
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        a.update_attributes(file: example)
+
+        expect(a.file.exists?).to be_truthy
+      end
+    end
+
+    it do
+      with_test_file("example.xml") do |example, real_filename|
+        a = klass.create!
+        a.update_attributes(file: example)
+
+        expect(a.file.filename).to eq real_filename
+      end
+    end
+
+    it do
+      with_test_file("example.xml") do |example, real_filename|
+        a = klass.create!
+        a.update_attributes(file: example)
+
+        expect(a.file.url).to eq "http://domain.com/store/dir/#{real_filename}"
+        expect(a.file.public_url).to eq a.file.url
+      end
+    end
+
+    it "don't create anything if save do not completes (halt during before_save)" do
+      klass = Class.new(Test) do
+        attr_accessor :fail_at_save
+        before_save { !fail_at_save }
+        include Saviour
+      end
+      klass.attach_file :file, uploader
+
+      expect {
+        a = klass.new
+        a.fail_at_save = true
+        a.save!
+      }.to raise_error(ActiveRecord::RecordNotSaved)
+
+      with_test_file("example.xml") do |example, _|
+        a = klass.new
+        a.fail_at_save = true
+        a.file = example
+
+        expect(Saviour::Config.storage).not_to receive(:write)
+        a.save
+      end
+    end
+  end
+
+  describe "deletion" do
+    it do
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        a.update_attributes(file: example)
+        expect(a.file.exists?).to be_truthy
+        expect(a.destroy).to be_truthy
+
+        expect(Saviour::Config.storage.exists?(a[:file])).to be_falsey
+      end
+    end
+  end
+
+  describe "updating" do
+    it do
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        a.update_attributes(file: example)
+
+        expect(Saviour::Config.storage.exists?(a[:file])).to be_truthy
+        previous_location = a[:file]
+
+        with_test_file("camaloon.jpg") do |example_2|
+          a.update_attributes(file: example_2)
+          expect(Saviour::Config.storage.exists?(a[:file])).to be_truthy
+
+          expect(Saviour::Config.storage.exists?(previous_location)).to be_falsey
+        end
+      end
+    end
+  end
+end