saviour 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa3f38c97bf8c5fee8d2696496b167b7ea312367
-  data.tar.gz: 6ca9294640f87778851e17d87676273e4f183472
+  metadata.gz: bc893ccb84bdea17562e885649be535589247449
+  data.tar.gz: b626abd923dbcde6e9a44f0a6c6e5f608d9e7f85
 SHA512:
-  metadata.gz: 0fa86cf2f8def862e78f0fb019cd90eb085495c4da0247a6b3fc97a8514b6277e1ec7252960ecb8a32cd6c242f520dde6406cbdb4e171ead83bff92b484fa3cd
-  data.tar.gz: ee7cf2411e9d881f2cd5c70fcc6a6bfa93e11b8c5197b9d73cff27a4823ad63991fdfe3a683c50e2bccc226c73f9fafcf43bf54c31a2b9f60d69881c38b5a160
+  metadata.gz: 76b2b7986d9c44f006396a445ec188973a44ffc5c631a48a7b089ce3585428ad9565e29cc42d6c1153d0aaf662c0d1039abc218d0121d37b3fd7357a9fe166b8
+  data.tar.gz: 42e2ca1a05a2e57233e80c4f4f90909095ec7b64b8858bc40b0bf2448d951391765521d618146f115b5bb61ac648a77568ec7d25196950f3316bc30bd7b74683

data/Gemfile

@@ -4,4 +4,4 @@ source 'https://rubygems.org'
 gemspec
 
 gem "codeclimate-test-reporter", group: :test, require: nil
-gem "simplecov", group: :test, require: nil
+gem "simplecov", group: :test, require: nil

data/README.md

@@ -270,12 +270,12 @@ to verify existence for every write.
 
 ## Source abstraction
 
-As mentioned before, you can use `File#assign` with any object that responds to `read`. This is already the case for `::File`,
+As mentioned before, you can use `File#assign` with any io like object that responds to `read` and `rewind`. This is already the case for `::File`,
 `Tempfile` or `IO`. Since a file requires also a filename, however, in those cases a random filename will be assigned
 (you can always set the filename using a processor later on).
 
 Additionally, if the object responds to `#original_filename` then that will be used as a filename instead of generating
-a random one.
+a random one, or, if the object responds to `#path` then `File.basename(path)` will be used as a name.
 
 You can create your own classes implementing this API to extend functionality. This library includes two of them: StringSource
 and UrlSource.

data/lib/saviour.rb

@@ -1,6 +1,3 @@
-require 'fileutils'
-require 'fog/aws'
-
 require 'saviour/version'
 require 'saviour/base_uploader'
 require 'saviour/file'
@@ -11,7 +8,6 @@ require 'saviour/string_source'
 require 'saviour/url_source'
 require 'saviour/model'
 require 'saviour/integrator'
-require 'saviour/attribute_name_calculator'
 require 'saviour/source_filename_extractor'
 require 'saviour/life_cycle'
 require 'saviour/persistence_layer'

data/lib/saviour/base_uploader.rb

@@ -1,13 +1,9 @@
-require_relative 'uploader/element'
 require_relative 'uploader/store_dir_extractor'
 require_relative 'uploader/processors_runner'
 
 module Saviour
   class BaseUploader
-    attr_reader :version_name
-
     def initialize(opts = {})
-      @version_name = opts[:version]
       @data = opts.fetch(:data, {})
     end
 
@@ -28,7 +24,7 @@ module Saviour
       raise RuntimeError, "Please use `store_dir` before trying to write" unless store_dir
 
       if Config.processing_enabled
-        contents, filename = Uploader::ProcessorsRunner.new(self, @version_name).run!(contents, filename)
+        contents, filename = Uploader::ProcessorsRunner.new(self).run!(contents, filename)
       end
 
       path = ::File.join(store_dir, filename)
@@ -45,17 +41,11 @@ module Saviour
         @processors ||= []
       end
 
-      def versions
-        @versions ||= []
-      end
-
       def process(name = nil, opts = {}, type = :memory, &block)
-        element = Uploader::Element.new(@current_version, name || block)
-
         if block_given?
-          processors.push(element: element, type: type)
+          processors.push(method_or_block: name || block, type: type)
         else
-          processors.push(element: element, type: type, opts: opts)
+          processors.push(method_or_block: name || block, type: type, opts: opts)
         end
       end
 
@@ -65,18 +55,7 @@ module Saviour
 
 
       def store_dir(name = nil, &block)
-        element = Uploader::Element.new(@current_version, name || block)
-        store_dirs.push(element)
-      end
-
-      def version(name, &block)
-        versions.push(name)
-
-        if block
-          @current_version = name
-          instance_eval(&block)
-          @current_version = nil
-        end
+        store_dirs.push(name || block)
       end
     end
   end

data/lib/saviour/config.rb

@@ -19,12 +19,17 @@ module Saviour
 
       def storage
         Thread.current["Saviour::Config"] ||= {}
-        Thread.current["Saviour::Config"][:storage] || Thread.main["Saviour::Config"][:storage] || NotImplemented.new
+        Thread.current["Saviour::Config"][:storage] || (Thread.main["Saviour::Config"] && Thread.main["Saviour::Config"][:storage]) || NotImplemented.new
       end
 
       def storage=(value)
         Thread.current["Saviour::Config"] ||= {}
         Thread.current["Saviour::Config"][:storage] = value
+
+        if Thread.main["Saviour::Config"].nil?
+          Thread.main["Saviour::Config"] ||= {}
+          Thread.main["Saviour::Config"][:storage] = value
+        end
       end
     end
   end

data/lib/saviour/file.rb

@@ -4,9 +4,8 @@ module Saviour
   class File
     attr_reader :persisted_path
 
-    def initialize(uploader_klass, model, attached_as, version = nil)
+    def initialize(uploader_klass, model, attached_as)
       @uploader_klass, @model, @attached_as = uploader_klass, model, attached_as
-      @version = version
       @source_was = @source = nil
     end
 
@@ -35,6 +34,9 @@ module Saviour
     def assign(object)
       raise(RuntimeError, "must respond to `read`") if object && !object.respond_to?(:read)
 
+      followers = @model.class.attached_followers_per_leader[@attached_as]
+      followers.each { |x| @model.send(x).assign(object) unless @model.send(x).changed? } if followers
+
       @source_data = nil
       @source = object
       @persisted_path = nil if object
@@ -86,7 +88,10 @@ module Saviour
     end
 
     def source_data
-      @source_data ||= @source.read
+      @source_data ||= begin
+        @source.rewind
+        @source.read
+      end
     end
 
     def blank?
@@ -97,7 +102,7 @@ module Saviour
     private
 
     def uploader
-      @uploader ||= @uploader_klass.new(version: @version, data: {model: @model, attached_as: @attached_as})
+      @uploader ||= @uploader_klass.new(data: { model: @model, attached_as: @attached_as })
     end
   end
 end

data/lib/saviour/integrator.rb

@@ -5,46 +5,40 @@ module Saviour
       @persistence_klass = persistence_klass
     end
 
-    def file_instantiator_hook(model, file_instance, attach_as, version)
-      layer = @persistence_klass.new(model)
-      file_instance.set_path!(layer.read(Saviour::AttributeNameCalculator.new(attach_as, version).name)) if layer.persisted?
-    end
-
-    def attach_file_hook(klass, attach_as, uploader_klass)
-      versions = uploader_klass.versions || []
-
-      ([nil] + versions).each do |version|
-        column_name = Saviour::AttributeNameCalculator.new(attach_as, version).name
-
-        if klass.table_exists? && !klass.column_names.include?(column_name.to_s)
-          raise RuntimeError, "#{klass} must have a database string column named '#{column_name}'"
-        end
-      end
-    end
-
     def setup!
       raise "You cannot include Saviour twice in the same class" if @klass.respond_to?(:attached_files)
 
       @klass.class_attribute :attached_files
-      @klass.attached_files = {}
+      @klass.attached_files = []
+      @klass.class_attribute :attached_followers_per_leader
+      @klass.attached_followers_per_leader = {}
+
+      klass = @klass
+      persistence_klass = @persistence_klass
 
-      a = self
-      b = @klass
+      @klass.define_singleton_method "attach_file" do |attach_as, *maybe_uploader_klass, **opts, &block|
+        klass.attached_files.push(attach_as)
+        uploader_klass = maybe_uploader_klass[0]
 
-      @klass.define_singleton_method "attach_file" do |attach_as, uploader_klass|
-        a.attach_file_hook(self, attach_as, uploader_klass)
+        if opts[:follow]
+          klass.attached_followers_per_leader[opts[:follow]] ||= []
+          klass.attached_followers_per_leader[opts[:follow]].push(attach_as)
+        end
 
-        versions = uploader_klass.versions || []
-        b.attached_files[attach_as] ||= []
-        b.attached_files[attach_as] += versions
+        if uploader_klass.nil? && block.nil?
+          raise ArgumentError, "you must provide either an UploaderClass or a block to define it."
+        end
 
-        b.class_eval do
-          define_method(attach_as) do |version = nil|
-            instance_variable_get("@__uploader_#{version}_#{attach_as}") || begin
-              new_file = ::Saviour::File.new(uploader_klass, self, attach_as, version)
-              a.file_instantiator_hook(self, new_file, attach_as, version)
+        mod = Module.new do
+          define_method(attach_as) do
+            instance_variable_get("@__uploader_#{attach_as}") || begin
+              uploader_klass = Class.new(Saviour::BaseUploader, &block) if block
+              new_file = ::Saviour::File.new(uploader_klass, self, attach_as)
 
-              instance_variable_set("@__uploader_#{version}_#{attach_as}", new_file)
+              layer = persistence_klass.new(self)
+              new_file.set_path!(layer.read(attach_as)) if layer.persisted?
+
+              instance_variable_set("@__uploader_#{attach_as}", new_file)
             end
           end
 
@@ -56,15 +50,15 @@ module Saviour
             send(attach_as).changed?
           end
         end
+
+        klass.include mod
       end
 
       @klass.class_attribute :__saviour_validations
 
-      class << @klass
-        def attach_validation(attach_as, method_name = nil, &block)
-          self.__saviour_validations ||= Hash.new { [] }
-          self.__saviour_validations[attach_as] += [method_name || block]
-        end
+      @klass.define_singleton_method("attach_validation") do |attach_as, method_name = nil, &block|
+        klass.__saviour_validations ||= Hash.new { [] }
+        klass.__saviour_validations[attach_as] += [method_name || block]
       end
     end
   end

data/lib/saviour/life_cycle.rb

@@ -8,50 +8,35 @@ module Saviour
     end
 
     def delete!
-      attached_files.each do |column, versions|
-        (versions + [nil]).each { |version| @model.send(column, version).delete if @model.send(column, version).exists? }
+      attached_files.each do |column|
+        @model.send(column).delete if @model.send(column).exists?
       end
     end
 
     def save!
-      attached_files.each do |column, versions|
+      attached_files.each do |column|
         base_file_changed = @model.send(column).changed?
-        original_content = @model.send(column).source_data if base_file_changed
-
-        versions.each do |version|
-          if @model.send(column, version).changed?
-            upload_file(column, version)
-          elsif base_file_changed
-            @model.send(column, version).assign(StringSource.new(original_content, default_version_filename(column, version)))
-            upload_file(column, version)
-          end
-        end
-
-        upload_file(column, nil) if base_file_changed
+
+        upload_file(column) if base_file_changed
       end
     end
 
 
     private
 
-    def default_version_filename(column, version)
-      filename = @model.send(column).filename_to_be_assigned
-      "#{::File.basename(filename, ".*")}_#{version}#{::File.extname(filename)}"
-    end
 
-    def upload_file(column, version)
-      name = AttributeNameCalculator.new(column, version).name
+    def upload_file(column)
       persistence_layer = @persistence_klass.new(@model) if @persistence_klass
-      current_path = persistence_layer.read(name) if persistence_layer
+      current_path = persistence_layer.read(column) if persistence_layer
 
       Config.storage.delete(current_path) if current_path
 
-      new_path = @model.send(column, version).write
-      persistence_layer.write(name, new_path) if persistence_layer
+      new_path = @model.send(column).write
+      persistence_layer.write(column, new_path) if persistence_layer
     end
 
     def attached_files
-      @model.class.attached_files || {}
+      @model.class.attached_files
     end
   end
 end

data/lib/saviour/model.rb

@@ -15,8 +15,8 @@ module Saviour
     end
 
     def reload
-      self.class.attached_files.each do |attach_as, versions|
-        (versions + [nil]).each { |version| instance_variable_set("@__uploader_#{version}_#{attach_as}", nil) }
+      self.class.attached_files.each do |attach_as|
+        instance_variable_set("@__uploader_#{attach_as}", nil)
       end
       super
     end

data/lib/saviour/s3_storage.rb

@@ -1,3 +1,5 @@
+require 'fog/aws'
+
 module Saviour
   class S3Storage
     def initialize(conf = {})
@@ -6,8 +8,8 @@ module Saviour
       @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.new("aws_access_key_id is required") }
+      conf.fetch(:aws_secret_access_key) { raise ArgumentError.new("aws_secret_access_key is required") }
     end
 
     def write(contents, path)
@@ -66,11 +68,11 @@ module Saviour
     end
 
     def directory
-      @directory ||= connection.directories.get(@bucket)
+      @directory ||= connection.directories.new(key: @bucket)
     end
 
     def connection
-      @connection ||= Fog::Storage.new({provider: 'AWS'}.merge(@conf))
+      @connection ||= Fog::Storage.new({ provider: 'AWS' }.merge(@conf))
     end
   end
 end

data/lib/saviour/string_source.rb

@@ -1,11 +1,16 @@
 module Saviour
   class StringSource
     def initialize(value, filename = nil)
-      @value, @filename = value, filename
+      @value = StringIO.new(value)
+      @filename = filename
     end
 
-    def read
-      @value
+    def read(*args)
+      @value.read(*args)
+    end
+
+    def rewind
+      @value.rewind
     end
 
     def original_filename

data/lib/saviour/uploader/processors_runner.rb

@@ -5,26 +5,26 @@ module Saviour
       attr_accessor :contents
       attr_accessor :filename
 
-      def initialize(uploader, version_name)
-        @uploader, @version_name = uploader, version_name
+      def initialize(uploader)
+        @uploader = uploader
       end
 
       def matching_processors
-        @uploader.class.processors.select { |processor| !processor[:element].versioned? || processor[:element].version == @version_name }
+        @uploader.class.processors
       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)
+      def run_method_or_block(method_or_block, opts, data)
+        if method_or_block.respond_to?(:call)
+          @uploader.instance_exec(data, filename, &method_or_block)
         else
           if opts.empty?
-            @uploader.send(element.method_or_block, data, filename)
+            @uploader.send(method_or_block, data, filename)
           else
-            @uploader.send(element.method_or_block, data, filename, opts)
+            @uploader.send(method_or_block, data, filename, opts)
           end
         end
       end
@@ -43,11 +43,11 @@ module Saviour
       end
 
       def run_processor(processor)
-        element = processor[:element]
+        method_or_block = processor[:method_or_block]
         opts = processor[:opts]
 
         if processor[:type] == :memory
-          result = run_element(element, opts, contents)
+          result = run_method_or_block(method_or_block, opts, contents)
 
           self.contents = result[0]
           self.filename = result[1]
@@ -55,7 +55,7 @@ module Saviour
         else
           file.rewind
 
-          result = run_element(element, opts, file)
+          result = run_method_or_block(method_or_block, opts, file)
 
           self.file = result[0]
           self.filename = result[1]