attachs 0.3.5 → 0.4.0

data/lib/attachs/active_record/connection_adapters.rb

@@ -0,0 +1,40 @@
+module Attachs
+  module ActiveRecord
+    module ConnectionAdapters
+      COLUMNS = {
+        filename:     'string',
+        content_type: 'string',
+        size:         'integer',
+        updated_at:   'datetime'
+      }
+
+      module AbstractAdapter
+        def add_attachment(table_name, *attachment_names)
+          attachment_names.each do |attachment_name|
+            COLUMNS.each do |column_name, column_type|
+              add_column table_name, "#{attachment_name}_#{column_name}", column_type
+            end
+          end
+        end
+
+        def remove_attachment(table_name, *attachment_names)
+          attachment_names.each do |attachment_name|
+            COLUMNS.each do |column_name, column_type|
+              remove_column table_name, "#{attachment_name}_#{column_name}"
+            end
+          end
+        end
+      end
+
+      module TableDefinition
+        def attachment(*attachment_names)
+          attachment_names.each do |attachment_name|
+            COLUMNS.each do |column_name, column_type|
+              column "#{attachment_name}_#{column_name}", column_type
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/attachs/active_record/migration.rb

@@ -0,0 +1,17 @@
+module Attachs
+  module ActiveRecord
+    module Migration
+      module CommandRecorder
+        def add_attachment(*args)
+          record :add_attachment, args
+        end
+
+        private
+
+        def invert_add_attachment(*args)
+          [:remove_attachment, args]
+        end
+      end
+    end
+  end
+end

data/lib/attachs/active_record/validators.rb

@@ -0,0 +1,7 @@
+module Attachs
+  module ActiveRecord
+    module Validators
+      extend ActiveSupport::Concern
+    end
+  end
+end

data/lib/attachs/active_record/validators/attachment_content_type_validator.rb

@@ -0,0 +1,30 @@
+module Attachs
+  module ActiveRecord
+    module Validators
+      class AttachmentContentTypeValidator < ActiveModel::EachValidator
+
+        def validate_each(record, attribute, value)
+          if value.exists?
+            if options.has_key? :with
+              if options[:with] !~ value.content_type
+                record.errors.add attribute, :attachment_content_type_with
+              end
+            elsif options.has_key? :in
+              if options[:in].exclude? value.content_type
+                record.errors.add attribute, :attachment_content_type_in, types: options[:in].to_sentence
+              end
+            end
+          end
+        end
+
+      end
+      module ClassMethods
+
+        def validates_attachment_content_type_of(*attr_names)
+          validates_with AttachmentContentTypeValidator, _merge_attributes(attr_names)
+        end
+
+      end
+    end
+  end
+end

data/lib/attachs/active_record/validators/attachment_presence_validator.rb

@@ -0,0 +1,22 @@
+module Attachs
+  module ActiveRecord
+    module Validators
+      class AttachmentPresenceValidator < ActiveModel::EachValidator
+
+        def validate_each(record, attribute, value)
+          if value.blank?
+            record.errors.add attribute, :attachment_presence
+          end
+        end
+
+      end
+      module ClassMethods
+
+        def validates_attachment_presence_of(*attr_names)
+          validates_with AttachmentPresenceValidator, _merge_attributes(attr_names)
+        end
+
+      end
+    end
+  end
+end

data/lib/attachs/active_record/validators/attachment_size_validator.rb

@@ -0,0 +1,39 @@
+module Attachs
+  module ActiveRecord
+    module Validators
+      class AttachmentSizeValidator < ActiveModel::EachValidator
+        include ActionView::Helpers::NumberHelper
+
+        def validate_each(record, attribute, value)
+          if value.exists?
+            if options.has_key? :in
+              if options[:in].exclude? value.size
+                record.errors.add(
+                  attribute,
+                  :attachment_size_in,
+                  min: number_to_human_size(options[:in].begin),
+                  max: number_to_human_size(options[:in].end)
+                )
+              end
+            else
+              if options.has_key? :less_than and value.size > options[:less_than]
+                record.errors.add attribute, :attachment_size_less_than, count: number_to_human_size(options[:less_than])
+              end
+              if options.has_key? :greater_than and value.size < options[:greater_than]
+                record.errors.add attribute, :attachment_size_greater_than, count: number_to_human_size(options[:greater_than])
+              end
+            end
+          end
+        end
+
+      end
+      module ClassMethods
+
+        def validates_attachment_size_of(*attr_names)
+          validates_with AttachmentSizeValidator, _merge_attributes(attr_names)
+        end
+
+      end
+    end
+  end
+end

data/lib/attachs/attachment.rb

@@ -0,0 +1,114 @@
+module Attachs
+  class Attachment
+
+    attr_reader :record, :attribute, :filename, :content_type, :size, :updated_at, :upload, :options
+
+    delegate :basename, :extension, :image?, :url, :process, :destroy, :update, to: :type
+
+    def initialize(record, attribute, options, source=false)
+      @record = record
+      @attribute = attribute
+      @options = options
+      case source
+      when nil
+        %w(filename content_type size updated_at).each do |name|
+          record.send "#{attribute}_#{name}=", nil
+        end
+      when false
+        %w(filename content_type size updated_at).each do |name|
+          instance_variable_set :"@#{name}", record.send("#{attribute}_#{name}")
+        end
+      else
+        load source
+        %w(filename content_type size updated_at).each do |name|
+          record.send "#{attribute}_#{name}=", send(name)
+        end
+      end
+    end
+
+    def uploaded!
+      @upload = nil
+    end
+
+    def styles
+      @styles ||= ((options[:styles] || []) | Attachs.config.global_styles)
+    end
+
+    def private?
+      @private ||= options[:private] == true
+    end
+
+    def public?
+      !private?
+    end
+
+    def upload?
+      !upload.nil?
+    end
+
+    def processed?
+      exists? and record.persisted? and !(
+        record.send("#{attribute}_filename_changed?") or
+        record.send("#{attribute}_content_type_changed?") or
+        record.send("#{attribute}_size_changed?") or
+        record.send("#{attribute}_updated_at_changed?")
+      )
+    end
+
+    def exists?
+      filename and content_type and size and updated_at
+    end
+
+    def blank?
+      !exists?
+    end
+
+    def default?
+      !options[:default_path].nil?
+    end
+
+    def url?
+      public? and (default? or processed?)
+    end
+
+    protected
+
+    def load(source)
+      if source.is_a? URI
+        download = Tempfile.new('external')
+        File.open(download.path, 'wb') do |file|
+          Net::HTTP.start(source.host) do |http|
+            file.write http.get(source.path).body
+          end
+        end
+        type = `file --mime-type -b '#{download.path}'`.strip
+        source = ActionDispatch::Http::UploadedFile.new(
+          tempfile: download,
+          filename: File.basename(source.path),
+          type: type
+        )
+      end
+      if source.is_a? Attachs::Attachment
+        @filename = source.filename
+        @updated_at = source.updated_at
+      else
+        @upload = source
+        @filename = source.original_filename.downcase
+        @updated_at = Time.zone.now
+      end
+      @content_type = source.content_type
+      @size = source.size
+    end
+
+    def type
+      @type ||= begin
+        if exists?
+          Attachs::Types::Regular.new(self)
+        else
+          Attachs::Types::Default.new(self)
+        end
+      end
+    end
+
+  end
+end

data/{config → lib/attachs}/locales/en.yml

@@ -2,7 +2,8 @@ en:
   errors:
     messages:
       attachment_presence: "can't be blank"
-      attachment_content_type: "the allowed types are: %{types}"
+      attachment_content_type_with: "has not allowed type"
+      attachment_content_type_in: "must be of one of the following types: %{types}"
       attachment_size_less_than: "size must be less than %{count}"
       attachment_size_greater_than: "size must be greater than %{count}"
       attachment_size_in: "size must be between %{min} and %{max}"

data/{config → lib/attachs}/locales/es.yml

@@ -2,7 +2,8 @@ es:
   errors:
     messages:
       attachment_presence: "no puede estar vacío"
-      attachment_content_type: "los formatos permitidos son: %{types}"
+      attachment_content_type_with: "tiene un formato no permitido"
+      attachment_content_type_in: "debe ser de uno de los siguientes formatos: %{types}"
       attachment_size_less_than: "debe pesar menos de %{count}"
       attachment_size_greater_than: "debe pesar más de %{count}"
       attachment_size_in: "debe pesar entre %{min} y %{max}"

data/lib/attachs/railtie.rb

@@ -1,18 +1,38 @@
 module Attachs
   class Railtie < Rails::Railtie
 
-    config.attachs = ActiveSupport::OrderedOptions.new
-    config.attachs.presets = {}
-    config.attachs.default_presets = []
-    config.attachs.default_validations = {}
-    config.attachs.base_url = ''
-    config.attachs.storage = :local
-
     initializer 'attachs' do
-      ::ActiveRecord::Base.send :include, Attachs::ActiveRecord::Base
-      if config.attachs.storage == :s3
-        require 'aws-sdk' 
-        Attachs::Storages::S3.config = YAML.load_file(Rails.root.join('config', 's3.yml'))
+      ::ActiveRecord::Base.send(
+        :include,
+        Attachs::ActiveRecord::Base,
+        Attachs::ActiveRecord::Validators
+      )
+      ::ActiveRecord::ConnectionAdapters::TableDefinition.send(
+        :include,
+        Attachs::ActiveRecord::ConnectionAdapters::TableDefinition
+      )
+      ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(
+        :include,
+        Attachs::ActiveRecord::ConnectionAdapters::AbstractAdapter
+      )
+      ::ActiveRecord::Migration::CommandRecorder.send(
+        :include,
+        Attachs::ActiveRecord::Migration::CommandRecorder
+      )
+      I18n.load_path += Dir[File.expand_path('../locales/*.yml', __FILE__)]
+    end
+
+    rake_tasks do
+      load 'tasks/attachs.rake'
+    end
+
+    config.after_initialize do
+      if Attachs.config.s3[:access_key_id] and Attachs.config.s3[:secret_access_key]
+        require 'aws-sdk'
+        AWS.config(
+          access_key_id: Attachs.config.s3[:access_key_id],
+          secret_access_key: Attachs.config.s3[:secret_access_key]
+        )
       end
     end
 

data/lib/attachs/storages/base.rb

@@ -0,0 +1,68 @@
+module Attachs
+  module Storages
+    class Base
+
+      def initialize(attachment)
+        @attachment = attachment
+      end
+
+      protected
+
+      attr_reader :attachment
+
+      def resize(*args)
+        Attachs::Tools::Magick.resize(*args)
+      end
+
+      def template
+        @template = begin
+          if attachment.exists?
+            (attachment.options[:path] || Attachs.config.default_path).dup
+          else
+            attachment.options[:default_path].dup
+          end.tap do |path|
+            path.scan(/:([a-zA-Z0-9_]+)/).flatten.uniq.map(&:to_sym).each do |name|
+              if name != :style
+                path.gsub! ":#{name}", interpolate(name)
+              end
+            end
+            path.squeeze! '/'
+            path.slice! 0 if path[0] == '/'
+          end
+        end
+      end
+
+      def path(style=:original)
+        template.gsub(':style', style.to_s)
+      end
+
+      def interpolate(name)
+        if interpolation = Attachs.config.interpolations[name]
+          interpolation.call(attachment).to_s.parameterize
+        else
+          case name
+          when :basename
+            attachment.basename.parameterize
+          when :filename
+            "#{attachment.basename.parameterize}.#{attachment.extension}"
+          when :size
+            attachment.size
+          when :extension
+            attachment.extension
+          when :type
+            attachment.content_type.split('/').first.parameterize
+          when :timestamp
+            (attachment.updated_at.to_f * 10000000000).to_i
+          when :class
+            attachment.record.class.name.parameterize
+          when :id
+            attachment.record.id
+          when :param
+            attachment.record.to_param
+          end.to_s
+        end
+      end
+
+    end
+  end
+end

data/lib/attachs/storages/local.rb

@@ -1,64 +1,88 @@
 module Attachs
   module Storages
-    class Local
+    class Local < Base
 
-      def initialize(default, private)
-        @tmp = (Rails.env.test? and !default)
-        @private = private
+      def url(style=:original)
+        if attachment.url?
+          base_url.join(path(style)).to_s
+        end
       end
 
-      def exists?(path)
-        ::File.exists? realpath(path)
+      def process(force=false)
+        if attachment.upload?
+          FileUtils.mkdir_p realpath.dirname
+          attachment.upload.rewind
+          File.open(realpath, 'wb') do |file|
+            while chunk = attachment.upload.read(16 * 1024)
+              file.write chunk
+            end
+          end
+          attachment.uploaded!
+        end
+        process_styles force
       end
 
-      def size(path)
-        ::File.size realpath(path)
-      end
-      
-      def realpath(path)
-        base_path.join path
+      def process_styles(force=false)
+        if attachment.image?
+          attachment.styles.each do |style|
+            if force == true
+              delete realpath(style)
+            end
+            unless File.exist? realpath(style)
+              FileUtils.mkdir_p realpath(style).dirname
+              resize realpath, style, realpath(style)
+            end
+          end
+        end
       end
 
-      def url(path)
-        ::File.join Rails.application.config.attachs.base_url, path unless private?
+      def destroy
+        delete realpath
+        destroy_styles
       end
 
-      def store(upload, path)
-        create_dir realpath(path)
-        upload.rewind # Hack to avoid empty files
-        ::File.open(realpath(path), 'wb') do |file|
-          while chunk = upload.read(16 * 1024)
-            file.write(chunk)
+      def destroy_styles
+        if attachment.image?
+          attachment.styles.each do |style|
+            delete realpath(style)
           end
         end
       end
-      
-      def delete(path)
-        ::File.delete realpath(path)
-      end
-
-      def magick(source, output, upload)
-        create_dir realpath(output)
-        yield Attachs::Magick::Image.new(realpath(source), realpath(output))
-      end
 
       protected
 
-      def tmp?
-        @tmp == true
+      def move(origin, destination)
+        FileUtils.mv base_path.join(origin), base_path.join(destination)
+      end
+
+      def delete(realpath)
+        if File.exist? realpath
+          File.delete realpath
+        end
       end
 
-      def private?
-        @private == true
+      def realpath(style=:original)
+        base_path.join(path(style))
       end
 
       def base_path
-        Rails.root.join tmp? ? 'tmp' : private? ? 'private' : 'public'
+        @base_path ||= begin
+          if attachment.private?
+            Rails.root.join 'private'
+          else
+            Rails.root.join 'public'
+          end
+        end
       end
 
-      def create_dir(path)
-        dir = base_path.join('uploads', path).dirname
-        FileUtils.mkdir_p dir unless ::File.directory? dir
+      def base_url
+        @base_url ||= begin
+          if Attachs.config.base_url.present?
+            Pathname.new Attachs.config.base_url
+          else
+            Pathname.new '/'
+          end
+        end
       end
 
     end