rails_uploads 0.1.4

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,87 @@
+=== NOTE: From version 0.1.3 and above RailsUploads::Engine renamed Rails::Uploads::Engine
+
+---
+
+{<img src="https://codeclimate.com/github/mattways/rails_uploads.png" />}[https://codeclimate.com/github/mattways/rails_uploads] {<img src="https://travis-ci.org/mattways/rails_uploads.png?branch=master" alt="Build Status" />}[https://travis-ci.org/mattways/rails_uploads] {<img src="https://gemnasium.com/mattways/rails_uploads.png" alt="Dependency Status" />}[https://gemnasium.com/mattways/rails_uploads]
+
+= Rails Uploads
+
+Minimalistic toolkit to handle file and images uploads using ActiveRecord.
+
+= Install
+
+Put this line in your Gemfile:
+  gem 'rails_uploads'
+  
+Then bundle:
+  $ bundle
+  
+= Usage
+
+Mount the engine at the end of you routes.rb:
+  mount Rails::Uploads::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 :prop
+  end
+
+If you need a file:
+  class Model < ActiveRecord::Base
+    attr_accessible :prop
+    attached_file :prop, :default => 'file.txt' # It's optional set a default file, the path it's relative to the public folder (used to generate the url)
+  end
+
+If you need a image:
+  class Model < ActiveRecord::Base
+    attr_accessible :prop
+    attached_image :prop, :presets => [:small, :big], :default => 'assets/image.jpg' # It's optional set a default image, the path it's relative to the publica folder (used to generate the url)
+  end
+
+Define presets in your application.rb
+  config.uploads.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.uploads.default_presets = [:small] # Define the default presets for all models with attached images
+
+The validation works very similar to paperclip:
+  class Model < ActiveRecord::Base
+    attr_accessible :prop
+    attached_file :prop
+    validates :prop, :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 # :less_than and :greater_than
+  errors.messages.attachment_size_less_than  # :less_than
+  errors.messages.attachment_size_greater_than # :greater_than
+  errors.messages.attachment_content_type # :types
+
+In your views:
+  a{ :href => record.file.path } # To get the file
+  a{ :href => record.image.path } # To get the original image
+  a{ :href => record.image.path(:big) } # To get the thumb
+  a{ :href => record.image.url(:big) } # If you want to use a base url
+
+In your forms:
+  = f.file_field :prop
+
+= FAQ
+
+== How can I use a cdn with this plugin?
+
+Just define a base url in your application.rb and use url method instead of path:
+  config.uploads.base_url = 'http://example.com'
+  
+== How can I clean a preset?
+
+Just remove the corresponding folder in uploads/images manually or with rake task:
+  rake uploads:preset:clean[preset]
+
+== How to migrate from versions before 0.1.0?
+
+To migrate from versions before 0.1.0 you need to reorganize uploads with this task after define your presets in your application.rb:
+  rake uploads:migrate

data/Rakefile

@@ -0,0 +1,40 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RailsUploads'
+  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/rails_uploads/application_controller.rb

@@ -0,0 +1,4 @@
+module RailsUploads
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/rails_uploads/presets_controller.rb

@@ -0,0 +1,14 @@
+module RailsUploads
+  class PresetsController < ApplicationController
+
+    def generate
+      filename = "#{params[:image]}.#{params[:format]}"
+      preset = params[:preset].gsub('-', '_').to_sym
+      if ::File.exists?(Rails.root.join('public', 'uploads', 'images', 'original', filename)) and Rails.application.config.uploads.presets.has_key?(preset)
+        RailsUploads::Types::Image.new(filename).send :generate_preset, preset
+        redirect_to request.url, :cb => Random.rand(100000)
+      end
+    end
+
+  end
+end

data/config/routes.rb

@@ -0,0 +1,5 @@
+RailsUploads::Engine.routes.draw do
+
+  match 'uploads/images/:preset/:image' => 'presets#generate', :status => 404
+
+end

data/lib/rails_uploads/active_record/base.rb

@@ -0,0 +1,122 @@
+module RailsUploads
+  module ActiveRecord
+    module Base
+      module NonAttachable
+    
+        def self.extended(base)
+          [:image].each do |type|
+            base.send(:define_singleton_method, "attached_#{type}") do |*args|
+              options = args.extract_options!
+              options[:type] = type
+              attached_file *args.append(options)
+            end
+          end       
+        end
+
+        def attached_file(*args)
+          options = args.extract_options!
+          options.reverse_merge! :type => :file
+          define_attachment *args.append(options)
+        end
+
+        def is_attachable?
+          not defined?(@attachments).nil?
+        end          
+
+        protected
+        
+        def define_attachment(*args)
+          options = args.extract_options!
+          make_attachable unless is_attachable?
+          args.each do |attr|
+            define_attachable_attribute_methods attr.to_sym, options
+            @attachments[attr.to_sym] = options
+          end
+        end
+
+        def make_attachable
+          send :include, RailsUploads::ActiveRecord::Base::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_attachable_attribute_methods(attr, options)
+          ['set', 'get'].each do |method|
+            send "define_attachable_attribute_method_#{method}", attr, options
+          end
+        end
+        
+        def define_attachable_attribute_method_set(attr, options)
+          define_method "#{attr}=" do |value|
+            @attachments = {} if defined?(@attachments).nil?
+            if value.is_a? ActionDispatch::Http::UploadedFile or value.is_a? Rack::Test::UploadedFile
+              @attachments[attr] = get_attachment_instance(value, options)
+              super(@attachments[attr].filename)
+            end
+          end 
+        end
+
+        def define_attachable_attribute_method_get(attr, options)
+          define_method attr do
+            @attachments = {} if defined?(@attachments).nil?
+            return @attachments[attr] if @attachments.has_key? attr
+            return nil if super().nil? and not options.has_key? :default
+            @attachments[attr] = get_attachment_instance(super(), options)
+          end 
+        end
+
+      end    
+      module Attachable
+
+        protected
+
+        def get_attachment_instance(source, options)
+          klass = options.has_key?(:type) ? options[:type].to_s.classify : 'File'
+          RailsUploads::Types.const_get(klass).new(source, options)  
+        end
+        
+        def check_changed_attachments
+          @stored_attachments = []
+          @deleted_attachments = []
+          self.class.instance_variable_get('@attachments').each do |attr, options|
+            if changed_attributes.has_key? attr.to_s
+              add_changed_attachment attributes[attr.to_s], options, :stored
+              add_changed_attachment changed_attributes[attr.to_s], options, :deleted
+            end
+          end
+        end
+        
+        def iterate_attachments
+          self.class.instance_variable_get('@attachments').each do |attr, options|
+            next unless value = send(attr)
+            yield value
+          end        
+        end
+        
+        def add_changed_attachment(value, options, type)
+          (type == :stored ? @stored_attachments : @deleted_attachments) << get_attachment_instance(value, options) unless value.nil?
+        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   
+     
+      end
+    end
+  end
+end

data/lib/rails_uploads/engine.rb

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

data/lib/rails_uploads/magick/image.rb

@@ -0,0 +1,83 @@
+module RailsUploads
+  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/width.to_f, max_height/height.to_f].max
+        convert :resize => "#{(scale*width).to_i}x#{(scale*height).to_i}", :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/width.to_f, max_height/height.to_f].min
+        convert :resize => "#{(scale*width).to_i}x#{(scale*height).to_i}", :gravity => 'center'
+      end
+
+      protected
+
+      def convert?
+        not (@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

data/lib/rails_uploads/railtie.rb

@@ -0,0 +1,14 @@
+module RailsUploads
+  class Railtie < Rails::Railtie
+
+    config.uploads = ActiveSupport::OrderedOptions.new
+    config.uploads.presets = {}
+    config.uploads.default_presets = []
+    config.uploads.base_url = ''
+
+    initializer 'rails_uploads' do
+      ::ActiveRecord::Base.send :extend, RailsUploads::ActiveRecord::Base::NonAttachable
+    end
+
+  end
+end

data/lib/rails_uploads/types/file.rb

@@ -0,0 +1,120 @@
+module RailsUploads
+  module Types
+    class File
+      
+      def initialize(source, options={})
+        if source.is_a? ActionDispatch::Http::UploadedFile or source.is_a? Rack::Test::UploadedFile
+          @upload = source          
+          @stored = false
+          @default = false
+        elsif source.is_a? String
+          @upload = false
+          @filename = source
+          @stored = true
+          @default = false
+        elsif options.has_key? :default
+          @upload = false
+          @filename = options[:default]
+          @stored = true
+          @default = true
+        end
+        @deleted = false        
+        @options = options
+      end
+
+      def has_default?
+        @default
+      end
+
+      def is_upload?
+        @upload != false
+      end
+
+      def is_stored?
+        @stored
+      end
+
+      def is_deleted?
+        @deleted
+      end 
+
+      def default_path(*args)
+        @options[:default]
+      end
+
+      def exists?(*args)
+        is_deleted? ? false : ::File.exists?(realpath(*args))
+      end
+
+      def size(*args)
+        return 0 if is_deleted?
+        (exists? ? ::File.size(realpath(*args)) : 0)
+      end
+
+      def extname
+        return nil if is_deleted?
+        @extname ||= ::File.extname(filename)
+      end   
+
+      def filename
+        return nil if is_deleted?
+        @filename ||= "#{(Time.now.to_f * 10000000).to_i}#{::File.extname @upload.original_filename}".downcase
+      end      
+
+      def path(*args)
+        return nil if is_deleted?
+        ::File.join('', public_path(*args))
+      end
+
+      def url(*args)
+        return nil if is_deleted?
+        ::File.join(Rails.application.config.uploads.base_url, path(*args))
+      end
+      
+      def realpath(*args)
+        return nil if is_deleted?
+        ::File.expand_path(is_stored? ? destination_path(*args) : @upload.path)
+      end
+
+      def store
+        if not is_stored? and is_upload?
+          check_store_dir
+          ::File.open(destination_path, 'wb') do |file|
+            file.write(@upload.read)
+          end
+          @stored = true
+          yield if block_given?
+        end
+      end
+      
+      def delete
+        if not has_default? and is_stored? and exists?
+          ::File.delete realpath
+          yield if block_given?
+          @stored = false
+          @deleted = true
+        end
+      end
+       
+      protected
+
+      def check_store_dir(*args)
+        dir = Rails.root.join('public', 'uploads', store_path(*args))
+        FileUtils.mkdir_p dir unless ::File.directory? dir
+      end
+
+      def destination_path(*args)
+        Rails.root.join('public', public_path(*args))
+      end
+
+      def public_path(*args)
+        has_default? ? default_path(*args) : ::File.join('uploads', store_path(*args), filename)
+      end
+
+      def store_path(*args)
+        'files'
+      end
+
+    end
+  end
+end