saviour 0.4.5 → 0.4.6

data/lib/saviour/local_storage.rb

@@ -2,17 +2,15 @@ require 'fileutils'
 
 module Saviour
   class LocalStorage
+    MissingPublicUrlPrefix = Class.new(StandardError)
+
     def initialize(opts = {})
       @local_prefix = opts[:local_prefix]
       @public_url_prefix = opts[:public_url_prefix]
-      @overwrite_protection = opts.fetch(:overwrite_protection, true)
     end
 
     def write(contents, path)
-      raise(RuntimeError, "The path you're trying to write already exists! (#{path})") if @overwrite_protection && exists?(path)
-
-      dir = ::File.dirname(real_path(path))
-      FileUtils.mkdir_p(dir) unless ::File.directory?(dir)
+      ensure_dir!(path)
 
       ::File.open(real_path(path), "w") do |f|
         f.binmode
@@ -20,15 +18,27 @@ module Saviour
       end
     end
 
+    def write_from_file(file, path)
+      ensure_dir!(path)
+
+      FileUtils.cp file.path, real_path(path)
+    end
+
+    def read_to_file(path, dest_file)
+      FileUtils.cp real_path(path), dest_file.path
+    end
+
     def read(path)
-      assert_exists(path)
       ::File.open(real_path(path)).read
+    rescue Errno::ENOENT
+      raise FileNotPresent, "Trying to read an unexisting path: #{path}"
     end
 
     def delete(path)
-      assert_exists(path)
       ::File.delete(real_path(path))
       ensure_removed_empty_dir(path)
+    rescue Errno::ENOENT
+      raise FileNotPresent, "Trying to delete an unexisting path: #{path}"
     end
 
     def exists?(path)
@@ -36,13 +46,30 @@ module Saviour
     end
 
     def public_url(path)
-      raise(RuntimeError, "You must provide a `public_url_prefix`") unless public_url_prefix
+      raise(MissingPublicUrlPrefix, "You must provide a `public_url_prefix`") unless public_url_prefix
       ::File.join(public_url_prefix, path)
     end
 
+    def cp(source_path, destination_path)
+      FileUtils.cp(real_path(source_path), real_path(destination_path))
+    rescue Errno::ENOENT
+      raise FileNotPresent, "Trying to cp an unexisting path: #{source_path}"
+    end
+
+    def mv(source_path, destination_path)
+      FileUtils.mv(real_path(source_path), real_path(destination_path))
+    rescue Errno::ENOENT
+      raise FileNotPresent, "Trying to mv an unexisting path: #{source_path}"
+    end
+
 
     private
 
+    def ensure_dir!(path)
+      dir = ::File.dirname(real_path(path))
+      FileUtils.mkdir_p(dir) unless ::File.directory?(dir)
+    end
+
     def public_url_prefix
       if @public_url_prefix.respond_to?(:call)
         @public_url_prefix.call
@@ -55,10 +82,6 @@ module Saviour
       @local_prefix ? ::File.join(@local_prefix, path) : path
     end
 
-    def assert_exists(path)
-      raise(RuntimeError, "File does not exists: #{path}") unless ::File.file?(real_path(path))
-    end
-
     def ensure_removed_empty_dir(path)
       basedir = ::File.dirname(path)
       return if basedir == "."

data/lib/saviour/model.rb

@@ -1,6 +1,4 @@
 module Saviour
-  NoActiveRecordDetected = Class.new(StandardError)
-
   module Model
     def self.included(klass)
       Integrator.new(klass, PersistenceLayer).setup!
@@ -9,7 +7,8 @@ module Saviour
         raise(NoActiveRecordDetected, "Error: ActiveRecord not detected in #{self}") unless self.ancestors.include?(ActiveRecord::Base)
 
         after_destroy { Saviour::LifeCycle.new(self, PersistenceLayer).delete! }
-        after_save { Saviour::LifeCycle.new(self, PersistenceLayer).save! }
+        after_update { Saviour::LifeCycle.new(self, PersistenceLayer).update! }
+        after_create { Saviour::LifeCycle.new(self, PersistenceLayer).create! }
         validate { Saviour::Validator.new(self).validate! }
       end
     end
@@ -20,5 +19,15 @@ module Saviour
       end
       super
     end
+
+    def dup
+      duped = super
+
+      self.class.attached_files.each do |attach_as|
+        duped.instance_variable_set("@__uploader_#{attach_as}", send(attach_as).dup)
+      end
+
+      duped
+    end
   end
 end

data/lib/saviour/s3_storage.rb

@@ -5,24 +5,24 @@ end
 
 module Saviour
   class S3Storage
+    MissingPublicUrlPrefix = Class.new(StandardError)
+    KeyTooLarge = Class.new(StandardError)
+
     def initialize(conf = {})
       @bucket = conf.delete(:bucket)
       @public_url_prefix = conf.delete(:public_url_prefix)
       @conf = conf
-      @overwrite_protection = conf.delete(:overwrite_protection) { true }
       @create_options = conf.delete(:create_options) { {} }
-      conf.fetch(:aws_access_key_id) { raise ArgumentError.new("aws_access_key_id is required") }
-      conf.fetch(:aws_secret_access_key) { raise ArgumentError.new("aws_secret_access_key is required") }
+      conf.fetch(:aws_access_key_id) { raise(ArgumentError, "aws_access_key_id is required") }
+      conf.fetch(:aws_secret_access_key) { raise(ArgumentError, "aws_secret_access_key is required") }
     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)
 
       # http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html
       if path.bytesize > 1024
-        raise(RuntimeError, "The key in S3 must be at max 1024 bytes, this key is too big: #{path}")
+        raise(KeyTooLarge, "The key in S3 must be at max 1024 bytes, this key is too big: #{path}")
       end
 
       directory.files.create({
@@ -33,30 +33,63 @@ module Saviour
       )
     end
 
+    def write_from_file(file, path)
+      write(file, path)
+    end
+
+    def read_to_file(path, dest_file)
+      dest_file.rewind
+      dest_file.write(read(path))
+    end
+
     def read(path)
-      path = sanitize_leading_slash(path)
-      assert_exists(path)
-      directory.files.get(path).body
+      real_path = sanitize_leading_slash(path)
+
+      file = directory.files.get(real_path)
+      raise FileNotPresent, "Trying to read an unexisting path: #{path}" unless file
+
+      file.body
     end
 
     def delete(path)
-      path = sanitize_leading_slash(path)
-      assert_exists(path)
-      directory.files.get(path).destroy
+      real_path = sanitize_leading_slash(path)
+
+      file = directory.files.get(real_path)
+      raise FileNotPresent, "Trying to delete an unexisting path: #{path}" unless file
+
+      file.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
+      raise(MissingPublicUrlPrefix, "You must provide a `public_url_prefix`") unless public_url_prefix
 
       path = sanitize_leading_slash(path)
       ::File.join(public_url_prefix, path)
     end
 
+    def cp(source_path, destination_path)
+      source_path = sanitize_leading_slash(source_path)
+      destination_path = sanitize_leading_slash(destination_path)
+
+      connection.copy_object(
+        @bucket, source_path,
+        @bucket, destination_path,
+        @create_options
+      )
+
+      FileUtils.cp(real_path(source_path), real_path(destination_path))
+    end
+
+    def mv(source_path, destination_path)
+      cp(source_path, destination_path)
+      delete(source_path)
+    end
 
     private
 
@@ -72,10 +105,6 @@ module Saviour
       path.gsub(/\A\/*/, '')
     end
 
-    def assert_exists(path)
-      raise RuntimeError, "File does not exists: #{path}" unless exists?(path)
-    end
-
     def directory
       @directory ||= connection.directories.new(key: @bucket)
     end

data/lib/saviour/source_filename_extractor.rb

@@ -5,7 +5,12 @@ module Saviour
     end
 
     def detected_filename
-      original_filename || path_filename
+      filename || original_filename || path_filename
+    end
+
+    def filename
+      value = @source.filename if @source.respond_to?(:filename)
+      value if !value.nil? && value != ''
     end
 
     def original_filename

data/lib/saviour/uploader/processors_runner.rb

@@ -35,6 +35,8 @@ module Saviour
             self.contents = ::File.read(file)
           else
             file.rewind
+            file.truncate(0)
+            file.binmode
             file.write(contents)
             file.flush
             file.rewind
@@ -75,14 +77,39 @@ module Saviour
         end
 
         if previous_type == :file
-          file.rewind
           self.contents = ::File.read(file)
         end
 
-        file.delete
+        file.close!
 
         [contents, filename]
       end
+
+      def run_as_file!(start_file, initial_filename)
+        @file = start_file
+        @contents = nil
+        @filename = initial_filename
+
+        previous_type = :file
+
+        matching_processors.each do |processor|
+          advance!(processor, previous_type)
+
+          run_processor(processor)
+          previous_type = processor[:type]
+        end
+
+        if previous_type == :memory
+          file.rewind
+          file.truncate(0)
+          file.binmode
+          file.write(contents)
+          file.flush
+          file.rewind
+        end
+
+        [file, filename]
+      end
     end
   end
 end

data/lib/saviour/url_source.rb

@@ -3,6 +3,10 @@ require 'net/http'
 
 module Saviour
   class UrlSource
+    TooManyRedirects = Class.new(StandardError)
+    InvalidUrl = Class.new(StandardError)
+    ConnectionFailed = Class.new(StandardError)
+
     MAX_REDIRECTS = 10
 
     def initialize(url)
@@ -33,7 +37,7 @@ module Saviour
     end
 
     def resolve(uri, max_redirects = MAX_REDIRECTS)
-      raise RuntimeError, "Max number of allowed redirects reached (#{MAX_REDIRECTS}) when resolving #{uri}" if max_redirects == 0
+      raise TooManyRedirects, "Max number of allowed redirects reached (#{MAX_REDIRECTS}) when resolving #{uri}" if max_redirects == 0
 
       response = Net::HTTP.get_response(uri)
 
@@ -51,12 +55,12 @@ module Saviour
       begin
         URI(url)
       rescue URI::InvalidURIError
-        raise ArgumentError, "'#{url}' is not a valid URI"
+        raise InvalidUrl, "'#{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
+      raise(ConnectionFailed, "Connection to #{@uri} failed after 3 attempts.") if n == 0
 
       block.call || with_retry(n - 1, &block)
     end

data/lib/saviour/validator.rb

@@ -1,16 +1,26 @@
 module Saviour
   class Validator
     def initialize(model)
-      raise "Please provide an object compatible with Saviour." unless model.class.respond_to?(:attached_files)
+      raise(ConfigurationError, "Please provide an object compatible with Saviour.") unless model.class.respond_to?(:attached_files)
 
       @model = model
     end
 
     def validate!
-      validations.each do |column, method_or_blocks|
-        raise(ArgumentError, "There is no attachment defined as '#{column}'") unless attached_files.include?(column)
+      validations.each do |column, declared_validations|
+        raise(ConfigurationError, "There is no attachment defined as '#{column}'") unless attached_files.include?(column)
         if @model.send(column).changed?
-          method_or_blocks.each { |method_or_block| run_validation(column, method_or_block) }
+          declared_validations.each do |data|
+            type = data[:type]
+            method_or_block = data[:method_or_block]
+
+            case type
+              when :memory
+                run_validation(column, method_or_block)
+              when :file
+                run_validation_as_file(column, method_or_block)
+            end
+          end
         end
       end
     end
@@ -37,6 +47,26 @@ module Saviour
       end
     end
 
+    def run_validation_as_file(column, method_or_block)
+      file = @model.send(column).source
+      filename = @model.send(column).filename_to_be_assigned
+      opts = { attached_as: column }
+
+      if method_or_block.respond_to?(:call)
+        if method_or_block.arity == 2
+          @model.instance_exec(file, filename, &method_or_block)
+        else
+          @model.instance_exec(file, filename, opts, &method_or_block)
+        end
+      else
+        if @model.method(method_or_block).arity == 2
+          @model.send(method_or_block, file, filename)
+        else
+          @model.send(method_or_block, file, filename, opts)
+        end
+      end
+    end
+
     def attached_files
       @model.class.attached_files
     end

data/lib/saviour/version.rb

@@ -1,3 +1,3 @@
 module Saviour
-  VERSION = "0.4.5"
+  VERSION = "0.4.6"
 end

data/saviour.gemspec

@@ -13,10 +13,10 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files`.split($/)
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.1.0"
+  spec.required_ruby_version = ">= 2.2.0"
 
-  spec.add_dependency "activerecord", ">= 4.0"
-  spec.add_dependency "activesupport", ">= 4.0"
+  spec.add_dependency "activerecord", ">= 5.0"
+  spec.add_dependency "activesupport", ">= 5.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rspec"
@@ -25,4 +25,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "appraisal"
   spec.add_development_dependency "fog-aws"
   spec.add_development_dependency "mime-types"
+  spec.add_development_dependency "get_process_mem"
 end

data/spec/feature/crud_workflows_spec.rb

@@ -139,22 +139,38 @@ describe "saving a new file" do
         end
       end
     end
+
+    it "does allow to update the same file to another contents in the same path" do
+      a = klass.create! file: Saviour::StringSource.new("contents", "file.txt")
+
+      a.update_attributes! file: Saviour::StringSource.new("foo", "file.txt")
+      expect(Saviour::Config.storage.read(a[:file])).to eq "foo"
+    end
   end
 
   describe "dupping" do
-    it "maintains file access" do
-      with_test_file("example.xml") do |example|
-        a = klass.create!
-        a.update_attributes(file: example)
+    let(:uploader) {
+      Class.new(Saviour::BaseUploader) {
+        store_dir { "/store/dir/#{model.id}" }
+      }
+    }
 
-        expect(Saviour::Config.storage.exists?(a[:file])).to be_truthy
+    it "creates a non persisted file attachment" do
+      a = klass.create! file: Saviour::StringSource.new("contents", "file.txt")
+      expect(Saviour::Config.storage.exists?(a[:file])).to be_truthy
 
-        b = a.dup
-        expect(b).to_not be_persisted
+      b = a.dup
+      expect(b).to_not be_persisted
+      expect(b.file).to_not be_persisted
+    end
 
-        expect(b.file?).to be true
-        expect(b.file.url).to eq a.file.url
-      end
+    it "can be saved" do
+      a = klass.create! file: Saviour::StringSource.new("contents", "file.txt")
+      b = a.dup
+      b.save!
+
+      expect(Saviour::Config.storage.exists?(b[:file])).to be_truthy
+      expect(Saviour::Config.storage.read(a[:file])).to eq Saviour::Config.storage.read(b[:file])
     end
   end
 end