attachs 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 54ae49b0a6e0cb9b5e170ac1b1559dd6e614055b
+  data.tar.gz: 273fcb21962f1b648de5d86064775d9b9b0dfddb
+SHA512:
+  metadata.gz: 2512efff14fad943789edf5867e952c558fed32fb25d31f4fde483015784d1cd2d5603075a2e33109b1b0fd8b3fce7ad8a74f0a2291265d60306f1cdadc8f6cd
+  data.tar.gz: c089f8e848fd436b8491144bf3a0ef57c00be075145cd8f495e6834faaf9333a1774efb37d621da9639da77dac5265a7572e0a7c417a340a69e5aeb542e9ab6b

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Mattways
+
+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.rdoc

@@ -0,0 +1,98 @@
+{<img src="https://codeclimate.com/github/mattways/attachs.png" />}[https://codeclimate.com/github/mattways/attachs] {<img src="https://travis-ci.org/mattways/attachs.png?branch=master" alt="Build Status" />}[https://travis-ci.org/mattways/attachs] {<img src="https://gemnasium.com/mattways/attachs.png" alt="Dependency Status" />}[https://gemnasium.com/mattways/attachs]
+
+= Attachs
+
+Minimalistic toolkit to attach file and images to records.
+
+= Install
+
+Put this line in your Gemfile:
+  gem 'attachs'
+  
+Then bundle:
+  $ bundle
+
+ImageMagick must be install, you can install it with homebrew:
+  brew install imagemagick
+  
+= Usage
+
+Mount the engine at the end of you routes.rb (only if you are using local storage):
+  mount Attachs:Engine: '/' # Will be use to generate on the fly missing image presets
+
+Add the column to your table (just a string):
+  create_table :models do |t|
+    t.string :attr
+  end
+
+If you need a file:
+  class Model < ActiveRecord::Base
+    has_attached_file :attr, default: 'file.txt'
+  end
+
+If you need a image:
+  class Model < ActiveRecord::Base
+    has_attached_image :attr, presets: [:small, :big], default: 'assets/image.jpg'
+  end
+
+Define presets in your application.rb
+  config.attachs.presets = {
+    big: { method: :fit, width: 1024, height: 768 }, # Fit will scale the image until it fit in the space without cropping
+    small: { method: :fill, width: 120, height: :120 }, # Fill will scale the image to fill all the space and then crop
+    custom: proc { |image| image.convert resize: '100x100' } # ImageMagick wrapper to do whatever you want
+  }
+  config.attachs.default_presets = [:small] # Define the default presets for all models with attached images
+  config.attachs.storage = :local # The default it's local, you can use :s3 as well
+
+If you want to use S3 create a s3.yml config file with this generator and complete it:
+  rails g attachs:s3:config
+
+The validation works very similar to paperclip:
+  class Model < ActiveRecord::Base
+    has_attached_file :attr
+    validates :attr, attachment_presence: true, attachment_size: { in: 0..4.megabytes }, attachment_content_type: { in: ['txt'] }
+  end
+
+If you want to translate the errores the keys are:
+  errors.messages.attachment_presence
+  errors.messages.attachment_size_in # :max and :min
+  errors.messages.attachment_size_less_than  # :count
+  errors.messages.attachment_size_greater_than # :count
+  errors.messages.attachment_content_type # :types
+
+In your views:
+  a{ href: record.file.url } # To get the file url
+  a{ href: record.image.url } # To get the original image
+  a{ href: record.image.url(:big) } # To get the a thumb
+
+In your forms:
+  = f.file_field :attr
+
+If your file it's optional:
+  = f.check_box :delete_attr
+
+= FAQ
+
+== How can I use a cdn with this plugin?
+
+Define a base url in your application.rb:
+  config.attachs.base_url = 'http://cdn.example.com'
+
+== How can I automatically create buckets?
+
+Use this rake task after create the s3.yml file:
+  rake attachs:s3:buckets:create
+  
+== How can I clean a preset?
+
+Use this rake task:
+  rake attachs:presets:clean MODEL=models PRESETS=first_preset,second_preset
+
+== How can I refresh a preset?
+
+Use this rake task:
+  rake attachs:presets:refresh MODEL=models PRESETS=first_preset,second_preset
+
+== How can I migrate from versions before 0.3.0
+
+All will work the same except from the name of the config parameter, replace uploads with attachs.

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Attachs'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/controllers/attachs/presets_controller.rb

@@ -0,0 +1,17 @@
+module Attachs
+  class PresetsController < ActionController::Base
+
+    def generate
+      filename = "#{params[:image]}.#{params[:format]}"
+      preset = params[:preset].gsub('-', '_').to_sym
+      if Rails.application.config.attachs.presets.has_key? preset
+        image = Attachs::Types::Image.new(filename)
+        if image.exists? and !image.exists?(preset)
+          image.generate_preset preset
+          redirect_to image.url(params[:preset]), cb: Random.rand(100000)
+        end
+      end
+    end
+
+  end
+end

data/config/locales/en.yml

@@ -0,0 +1,8 @@
+en:
+  errors:
+    messages:
+      attachment_presence: "can't be blank"
+      attachment_content_type: "the allowed types are: %{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/locales/es.yml

@@ -0,0 +1,8 @@
+es:
+  errors:
+    messages:
+      attachment_presence: "no puede estar vacío"
+      attachment_content_type: "los formatos permitidos son: %{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/config/routes.rb

@@ -0,0 +1,5 @@
+Attachs::Engine.routes.draw do
+
+  get 'uploads/images/:preset/:image.:format', to: 'presets#generate', status: 404
+
+end

data/lib/attachs.rb

@@ -0,0 +1,16 @@
+require 'attachs/active_record/base'
+require 'attachs/magick/image'
+require 'attachs/storages/local'
+require 'attachs/storages/s3'
+require 'attachs/types/file'
+require 'attachs/types/image'
+require 'attachs/validators/base'
+require 'attachs/validators/attachment_content_type_validator'
+require 'attachs/validators/attachment_presence_validator'
+require 'attachs/validators/attachment_size_validator'
+require 'attachs/engine'
+require 'attachs/railtie'
+require 'attachs/version'
+
+module Attachs
+end

data/lib/attachs/active_record/base.rb

@@ -0,0 +1,145 @@
+module Attachs
+  module ActiveRecord
+    module Base
+      extend ActiveSupport::Concern
+
+      included do
+        singleton_class.class_eval do
+          [:file, :image].each do |type|
+            name = :"has_attached_#{type}"
+            define_method name do |*args|
+              options = args.extract_options!
+              options[:type] = type
+              define_attachment *args.append(options)
+            end
+            alias_method :"attached_#{type}", name
+          end
+        end
+      end
+
+      protected
+
+      attr_reader :stored_attachments, :deleted_attachments
+
+      def attachments
+        @attachments ||= {}
+      end
+
+      def build_attachment_instance(source, options)
+        klass = options.has_key?(:type) ? options[:type].to_s.classify : 'File'
+        Attachs::Types.const_get(klass).new source, options
+      end
+      
+      def check_changed_attachments
+        @stored_attachments = []
+        @deleted_attachments = []
+        self.class.attachments.each do |attr, options|
+          if changed_attributes.has_key? attr.to_s
+            stored = attributes[attr.to_s]
+            deleted = changed_attributes[attr.to_s]
+            add_changed_attachment stored, options, :stored if stored.present?
+            add_changed_attachment deleted, options, :deleted if deleted.present?
+          end
+        end
+      end
+      
+      def iterate_attachments
+        self.class.attachments.each do |attr, options|
+          next unless instance = send(attr)
+          yield instance
+        end
+      end
+      
+      def add_changed_attachment(source, options, type)
+        (type == :stored ? stored_attachments : deleted_attachments) << (source.is_a?(String) ? build_attachment_instance(source, options) : source)
+      end
+      
+      def store_attachments
+        iterate_attachments { |a| a.store }
+      end
+
+      def delete_attachments
+        iterate_attachments { |a| a.delete }  
+      end
+      
+      def remove_stored_attachments
+        stored_attachments.each { |a| a.delete }
+      end
+   
+      def remove_deleted_attachments
+        deleted_attachments.each { |a| a.delete }
+      end   
+
+      module ClassMethods
+
+        attr_reader :attachments
+    
+        def inherited(subclass)
+          subclass.instance_variable_set(:@attachments, @attachments)
+          super
+        end
+
+        def attachable?
+          attachments.present?
+        end
+
+        protected
+        
+        def define_attachment(*args)
+          options = args.extract_options!
+          make_attachable unless attachable?
+          args.each do |attr|
+            define_attachable_attribute_methods attr.to_sym, options
+            define_default_validations attr.to_sym, options
+            attachments[attr.to_sym] = options
+          end
+        end
+
+        def make_attachable
+          before_save :store_attachments, :check_changed_attachments
+          after_save :remove_deleted_attachments
+          before_destroy :delete_attachments           
+          after_rollback :remove_stored_attachments 
+          @attachments = {}
+        end
+
+        def define_default_validations(attr, options)
+          default_validations = Rails.application.config.attachs.default_validations[options[:type]]
+          validates attr, default_validations.dup if default_validations.present?
+        end
+
+        def define_attachable_attribute_methods(attr, options)
+          ['set','get'].each { |method| send "define_attachable_attribute_method_#{method}", attr, options }
+        end
+        
+        def define_attachable_attribute_method_set(attr, options)
+          define_method "#{attr}=" do |value|
+            if value.is_a? ActionDispatch::Http::UploadedFile or value.is_a? Rack::Test::UploadedFile or (value.is_a? String and value =~ /^[a-zA-Z0-9_-]+\.[a-zA-z]+$/)
+              attachment = build_attachment_instance(value, options)
+              attachments[attr] = attachment
+              write_attribute attr, attachment.filename 
+            end
+          end
+          define_method "delete_#{attr}=" do |value|
+            if attribute_present? attr and value == '1'
+              send "#{attr}_will_change!"
+              attachments[attr] = nil
+              attributes[attr.to_s] = nil
+            end
+            instance_variable_set("@delete_#{attr}".to_sym, value)
+          end
+        end
+
+        def define_attachable_attribute_method_get(attr, options)
+          define_method attr do
+            return attachments[attr] if attachments.has_key? attr
+            return nil if super().nil? and not options.has_key? :default
+            attachments[attr] = build_attachment_instance(super(), options)
+          end 
+          attr_reader :"delete_#{attr}"
+        end
+
+      end    
+    end
+  end
+end

data/lib/attachs/engine.rb

@@ -0,0 +1,7 @@
+module Attachs
+  class Engine < Rails::Engine
+
+    isolate_namespace Attachs
+
+  end
+end

data/lib/attachs/magick/image.rb

@@ -0,0 +1,85 @@
+module Attachs
+  module Magick
+    class Image
+
+      def initialize(source, output=nil)
+        @source = source
+        @output = output
+      end
+
+      def convert(args)
+        tokens = [convert? ? 'convert' : 'mogrify']
+        file_to_tokens tokens
+        args_to_tokens args, tokens
+        tokens << "\"#{output}\"" if convert?
+        success, output = run(tokens)
+        if block_given? 
+          yield success, output
+        else
+          success
+        end
+      end
+
+      def identify(args)
+        tokens = ['identify']
+        args_to_tokens args, tokens
+        file_to_tokens tokens
+        success, output = run(tokens)
+        if block_given?
+          yield success, output
+        else
+          success
+        end
+      end
+
+      def dimensions
+        identify(format: '%wx%h') do |success, output|
+          success ? output.chomp.split('x').map(&:to_i) : []
+        end
+      end
+
+      def width
+        dimensions[0]
+      end
+
+      def height
+        dimensions[1]
+      end
+
+      def resize_to_fill(max_width, max_height)
+        width, height = dimensions
+        scale = [max_width.to_f/width, max_height.to_f/height].max
+        convert resize: "#{(scale*width).ceil}x#{(scale*height).ceil}", gravity: 'center', crop: "#{max_width}x#{max_height}+0+0" 
+      end
+
+      def resize_to_fit(max_width, max_height)
+        width, height = dimensions
+        scale = [max_width.to_f/width, max_height.to_f/height].reject{ |s| s==0 }.min
+        convert resize: "#{(scale*width).ceil}x#{(scale*height).ceil}", gravity: 'center'
+      end
+
+      protected
+
+      attr_reader :source, :output
+
+      def convert?
+        !(output.nil? and ::File.exists?(output))
+      end
+  
+      def file_to_tokens(tokens)
+        tokens << (convert? ? "\"#{source}\"" : output)
+      end
+    
+      def args_to_tokens(args, tokens)
+        args.each { |k, v| tokens << "-#{k} #{v}" }
+      end
+
+      def run(tokens)
+        output = `#{tokens.join(' ')}`
+        success = $?.exitstatus == 0 
+        [success, output]
+      end 
+
+    end
+  end
+end