attachinary 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 Milovan Zogovic
+
+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.md

@@ -0,0 +1,96 @@
+# Attachinary
+
+Handling image and raw file attachments with ease.
+It uses [Cloudinary](http://cloudinary.com) as storage.
+
+It is structured as mountable rails engine.
+
+
+## Installation
+
+Add following line to your `Gemfile`:
+
+    gem 'attachinary'
+
+Then, run following rake command in terminal to create necessary tables:
+
+	rake attachinary:install:migrations
+	rake db:migrate
+
+Add following line in your `routes.rb` file to mount the engine:
+
+	mount Attachinary::Engine => "/attachinary"
+
+That's it. Oh, and make sure that you have [cloudinary gem](https://github.com/cloudinary/cloudinary_gem) installed and properly configured.
+
+
+## Usage
+
+Lets say that we want all of our **users** to have single **avatar** and many **photos** in their gallery. We also want *avatar* to be required. We also want to limit the number of photos user can upload to 10. We can declare it like this:
+
+	class User < ActiveRecord::Base
+		...
+		has_attachment  :avatar, accept: ['jpg', 'png', 'gif']
+		has_attachments :photos, maximum: 10
+
+		validates :avatar_id, presence: true
+		...
+	end
+
+In our `_form.html.erb` template, we need to add only this:
+
+	<%= attachinary_file_field_tag 'user[avatar_id]', user.avatar_id, attachinary: user.avatar_options %>
+	<%= attachinary_file_field_tag 'user[photo_ids]', user.photo_ids, attachinary: user.photo_options %>
+
+If you're using [SimpleForm](https://github.com/plataformatec/simple_form), you can even shorten this to:
+
+	<%= f.input :avatar, as: :attachinary %>
+	<%= f.input :photos, as: :attachinary %>
+
+Finally, you have to include `attachinary` into your asset pipeline. In your `application.js`, add following line:
+
+	//= require attachinary
+
+And, add this code on document ready:
+
+	$('.attachinary-input').attachinary()
+
+Attachinary jquery plugin is based upon [jQuery File Upload plugin](https://github.com/blueimp/jQuery-File-Upload) but without any fancy UI (it leaves it up to you to decorate it).
+
+Plugin is fully customizable. It uses John Resig's micro templating in the background, but you can override it with whatever you like. Check out the source code for more configuration options you can set.
+
+### Displaying avatar and photos
+
+Here comes the good part. There is no need to transform images on your server. Instead, you can request image transformations directly from Cloudinary. First time you request image, it is created and cached on the Cloudinary server for later use. Here is sample code that you can use in your `_user.html.erb` partial:
+
+	<% if @user.avatar? %>
+		<%= cl_image_tag(@user.avatar.path, { size: '50x50', crop: :face }) %>
+	<% end %>
+
+	<% @user.photos.each do |photo| %>
+		<%= cl_image_tag(photo.path, { size: '125x125', crop: :fit }) %>
+	<% end %>
+
+Avatar will be automatically cropped to 50x50px to show only user face. You read it right: **face detection** :) All other user photos are just cropped to fit within 125x125.
+
+Whenever you feel like changing image sizes, you don't need to set rake task that will take forever to re-process thousands of photos. You just change the dimension in your partial and thats it.
+
+
+## Conventions
+
+* always use singular name for `has_attachment`
+* always use plural name for `has_attachments`
+
+
+## Requirements and Compatibility
+
+* Cloudinary
+* Ruby 1.9
+* Rails 3.2+
+
+
+## Credits and License
+
+Developed by Milovan Zogovic.
+
+This software is released under the MIT License.

data/Rakefile

@@ -0,0 +1,43 @@
+#!/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    = 'Attachinary'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+#require 'rake/spectask'
+
+# Spec::Rake::SpecTask.new(:spec) do |t|
+#   t.libs << 'lib'
+#   t.libs << 'spec'
+#   t.pattern = 'spec/**/*_spec.rb'
+#   t.verbose = false
+# end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+

data/app/controllers/attachinary/application_controller.rb

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

data/app/controllers/attachinary/cors_controller.rb

@@ -0,0 +1,9 @@
+module Attachinary
+  class CorsController < Attachinary::ApplicationController
+    respond_to :json
+
+    def show
+      respond_with request.query_parameters
+    end
+  end
+end

data/app/controllers/attachinary/files_controller.rb

@@ -0,0 +1,21 @@
+module Attachinary
+  class FilesController < Attachinary::ApplicationController
+    respond_to :json
+
+    def callback
+      success = valid_cloudinary_response?
+      if success && !params[:error].present?
+        @file = File.create(file_params)
+        respond_with @file
+      else
+        render nothing: true, status: 400
+      end
+    end
+
+  private
+    def file_params
+      request.query_parameters.slice(:public_id, :version, :width, :height, :format, :resource_type)
+    end
+
+  end
+end

data/app/models/attachinary/attachment.rb

@@ -0,0 +1,10 @@
+module Attachinary
+  class Attachment < ::ActiveRecord::Base
+    belongs_to :parent, polymorphic: true, touch: true
+    belongs_to :file, class_name: 'Attachinary::File', foreign_key: 'file_id'
+
+    validates :parent_id, :parent_type, :scope, presence: true
+
+    attr_accessible :parent_id, :parent_type, :file_id
+  end
+end

data/app/models/attachinary/file.rb

@@ -0,0 +1,39 @@
+module Attachinary
+  class File < ::ActiveRecord::Base
+    validates :public_id, :version, presence: true
+    validates :resource_type, presence: true
+
+    attr_accessible :public_id, :version, :width, :height, :format, :resource_type
+    after_destroy :destroy_file
+
+    def as_json(options)
+      super(only: [:id, :public_id, :format, :version, :resource_type], methods: [:path])
+    end
+
+    def path(custom_format=nil)
+      p = "v#{version}/#{public_id}"
+      if resource_type == 'image' && custom_format != false
+        custom_format ||= format
+        p<< ".#{custom_format}"
+      end
+      p
+    end
+
+    def fullpath(options={})
+      format = options.delete(:format)
+      Cloudinary::Utils.cloudinary_url(path(format), options)
+    end
+
+    def self.upload!(file)
+      if file.respond_to?(:read)
+        response = Cloudinary::Uploader.upload(file, tags: "env_#{Rails.env}")
+        create! response.slice('public_id', 'version', 'width', 'height', 'format', 'resource_type')
+      end
+    end
+
+  private
+    def destroy_file
+      Cloudinary::Uploader.destroy(public_id) if public_id
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,4 @@
+Attachinary::Engine.routes.draw do
+  get '/cors' => 'cors#show', format: 'json', as: 'cors'
+  get '/callback' => 'files#callback', format: 'json', as: 'callback'
+end

data/lib/attachinary.rb

@@ -0,0 +1,4 @@
+require "attachinary/engine"
+
+module Attachinary
+end

data/lib/attachinary/active_record_extension.rb

@@ -0,0 +1,187 @@
+module Attachinary
+  module ActiveRecordExtension
+
+    def has_attachment(scope, options={})
+      apply_defaults!(options)
+
+      # has_one :photo_attachment, ...
+      has_one :"#{scope}_attachment",
+        as: :parent,
+        class_name: '::Attachinary::Attachment',
+        conditions: { scope: scope.to_s },
+        dependent: :destroy
+
+      # has_one :photo_attachment_file, through: :photo_attachment, ...
+      has_one :"#{scope}_attachment_file",
+        through: :"#{scope}_attachment",
+        source: :file
+
+      # attr_accessible :photo_id, :photo_file
+      attr_accessible :"#{scope}_id", :"#{scope}_file" if options[:accessible]
+
+      # attr_accessor :photo
+      attr_accessor :"#{scope}"
+
+      # def photo_id=(id)
+      #   photo = ::Attachinary::File.find_by_id(id)
+      # end
+      define_method :"#{scope}_id=" do |id|
+        send(:"#{scope}=", ::Attachinary::File.find_by_id(id))
+      end
+
+      # def photo_file=(f)
+      #   photo = ::Attachinary::File.upload!(f)
+      # end
+      define_method :"#{scope}_file=" do |f|
+        send(:"#{scope}=", ::Attachinary::File.upload!(f))
+      end
+
+      # def photo_id
+      #   photo.try(:id)
+      # end
+      define_method :"#{scope}_id" do
+        send(:"#{scope}").try(:id)
+      end
+
+      # def photo?
+      #   photo.present?
+      # end
+      define_method :"#{scope}?" do
+        send(:"#{scope}").present?
+      end
+
+
+      # after_initialize do
+      #   unless photo?
+      #     photo = photo_attachment_file
+      #   end
+      # end
+      after_initialize do
+        unless send(:"#{scope}?")
+          send(:"#{scope}=", send(:"#{scope}_attachment_file"))
+        end
+      end
+
+      # before_save do
+      #   photo_attachment_file = photo
+      # end
+      before_save do
+        send(:"#{scope}_attachment_file=", send(:"#{scope}"))
+      end
+
+      # def photo_options
+      #   options.merge({
+      #     field_name: "photo_id",
+      #     maximum: 1
+      #   })
+      # end
+      define_method :"#{scope}_options" do
+        options.merge({
+          field_name: "#{scope}_id",
+          file_field_name: "#{scope}_file",
+          single: true,
+          maximum: 1
+        })
+      end
+    end
+
+    def has_attachments(scope, options={})
+      apply_defaults!(options)
+      singular = scope.to_s.singularize
+
+      # has_many :image_attachments
+      has_many :"#{singular}_attachments",
+        as: :parent,
+        class_name: '::Attachinary::Attachment',
+        conditions: { scope: scope.to_s },
+        dependent: :destroy
+
+      # has_many :image_attachment_files, through: :image_attachments
+      has_many :"#{singular}_attachment_files",
+        through: :"#{singular}_attachments",
+        source: :file
+
+      # attr_accessible :image_ids, :image_files
+      attr_accessible :"#{singular}_ids", :"#{singular}_files" if options[:accessible]
+
+      # attr_accessor :images
+      attr_accessor :"#{scope}"
+
+      # def image_ids=(ids)
+      #   files = [ids].flatten.compact.uniq.reject(&:blank?) do |id|
+      #     ::Attachinary::File.find_by_id(id)
+      #   end.compact
+      #   images = files
+      # end
+      define_method :"#{singular}_ids=" do |ids|
+        files = [ids].flatten.compact.uniq.reject(&:blank?).map do |id|
+          ::Attachinary::File.find_by_id(id)
+        end.compact
+        send(:"#{scope}=", files)
+      end
+
+      # def image_files=(fs)
+      #   files = fs.map { |f| ::Attachinary::File.upload!(f) }
+      #   images = files
+      # end
+      define_method :"#{singular}_files=" do |fs|
+        files = fs.map{ |f| ::Attachinary::File.upload!(f) }.compact
+        send(:"#{scope}=", files)
+      end
+
+      # def image_ids
+      #   images.map(&:id)
+      # end
+      define_method :"#{singular}_ids" do
+        send(:"#{scope}").map(&:id)
+      end
+
+      # def images?
+      #   images.present?
+      # end
+      define_method :"#{scope}?" do
+        send(:"#{scope}").present?
+      end
+
+
+      # after_initialize do
+      #   unless images?
+      #     images = image_attachment_files
+      #   end
+      # end
+      after_initialize do
+        unless send(:"#{scope}?")
+          send(:"#{scope}=", send(:"#{singular}_attachment_files"))
+        end
+      end
+
+      # before_save do
+      #   image_attachment_files = images
+      # end
+      before_save do
+        send(:"#{singular}_attachment_files=", send(:"#{scope}"))
+      end
+
+      # def image_options
+      #   options.merge({
+      #     field_name: "image_ids"
+      #   })
+      # end
+      define_method :"#{singular}_options" do
+        options.merge({
+          field_name: "#{singular}_ids",
+          file_field_name: "#{singular}_files",
+          single: false
+        })
+      end
+    end
+
+  private
+    def apply_defaults!(options)
+      options.reverse_merge!({
+        accessible: true
+      })
+    end
+
+  end
+end