effective_assets 0.1

data/app/models/validators/asset_box_presence_validator.rb

@@ -0,0 +1,6 @@
+class AssetBoxPresenceValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    num_in_box = (record.attachments || []).select { |attachment| attachment.box == attribute.to_s.pluralize && attachment.marked_for_destruction? == false }.size
+    record.errors[attribute] << "can't be blank" if num_in_box == 0
+  end
+end

data/app/uploaders/asset_uploader.rb

@@ -0,0 +1,26 @@
+class AssetUploader < EffectiveAssetsUploader
+  # resize_to_fit
+  # Resize the image to fit within the specified dimensions while retaining the
+  # original aspect ratio. The image may be shorter or narrower than specified in the smaller dimension
+  # but will not be larger than the specified values.
+  #
+  # Probably best for taking a big image and making it smaller.
+  # Keeps the aspect ratio
+  # An uploaded image that is smaller will not be made bigger.
+
+  # resize_to_fill
+  # Resize the image to fit within the specified dimensions while retaining the
+  # aspect ratio of the original image. If necessary, crop the image in the larger dimension.
+
+  # resize_to_limit
+  # http://stackoverflow.com/questions/8570181/carrierwave-resizing-images-to-fixed-width
+  # Keep in mind, resize_to_fit will scale up images if they are smaller than 100px.
+  # If you don't want it to do that, then replace that with resize_to_limit.
+
+  version :thumb, :if => :image? do
+    process :resize_to_fit => [70, 70]
+    process :record_info => :thumb
+  end
+
+end
+

data/app/uploaders/effective_assets_uploader.rb

@@ -0,0 +1,63 @@
+class EffectiveAssetsUploader < CarrierWave::Uploader::Base
+  include CarrierWave::MiniMagick
+  storage :fog
+
+  def store_dir
+    "#{EffectiveAssets.aws_final_path.chomp('/')}/#{model.id}"
+  end
+
+  # Returns a Hash as per the versions above
+  # {:thumb=>{:width=>256, :height=>70}, :full_page=>{:width=>940, :height=>nil}}
+  def versions_info
+    @versions_info ||= calculate_versions_info
+  end
+
+  protected
+
+  # record_info
+  # Messy hash merging to a serialized field.
+  # It has the effect of setting asset.versions_info to a Hash, such as
+  #---
+  # :medium:
+  #   :data_size: 22259
+  #   :height: 400
+  #   :width: 400
+  # :thumb:
+  #   :data_size: 3105
+  #   :height: 128
+  #   :width: 128
+
+  def record_info(version)
+    if model and model.respond_to?(:versions_info) and @file.present?
+      info = {}
+      info[:data_size] = @file.size
+
+      img = MiniMagick::Image.open(@file.file)
+      info[:width] = img[:width]
+      info[:height] = img[:height]
+
+      model.versions_info.merge!({version.to_sym => info})
+    end
+  end
+
+  def image?(new_file)
+    new_file.present? and new_file.content_type.to_s.include?('image') and !(new_file.content_type.include?('icon'))
+  end
+
+  def calculate_versions_info
+    retval = {}
+
+    self.class.versions.each do |k, v|
+      v[:uploader].processors.each do |processor|
+        dimensions = processor[1]
+
+        if processor[0].to_s.include?('resize') and dimensions.kind_of?(Array) and dimensions.length == 2
+          retval[k] = {:width => dimensions.first, :height => dimensions.last}
+          break
+        end
+      end
+    end
+
+    retval
+  end
+end

data/app/views/active_admin/effective_assets/_edit.html.haml

@@ -0,0 +1,35 @@
+= semantic_form_for [:admin, asset] do |f|
+  = f.inputs "Asset" do
+    %li
+      %label.label Asset
+      %p.inline-hints= effective_asset_image_tag(asset, :thumb)
+    %li
+      %label.label Uploaded by
+      %p
+        - if defined? User
+          = asset.try(:user)
+    = f.input :title, :hint => "Give this asset a title"
+    = f.input :description, :as => :string, :hint => "Give this asset a description"
+    = f.input :tags, :hint => "Used for searching and filtering.  Separate multiple tags with a comma (i.e. blue,car,ford)"
+    = f.input :content_type, :hint => "The computer detected type of file.  Be careful when changing this value as you may break things."
+    %li
+      %label.label Files
+      %p.inline-hints{:style => 'font-style: normal'}
+        - if asset.image?
+          = link_to "Original", assets_image_url(asset), :class => 'asset-insertable', :data => {'asset-id' => asset.id, 'asset' => effective_asset_image_tag(asset)}
+          = "#{asset.width || '?'}x#{asset.height || '?'}px #{number_to_human_size(asset.data_size, :precision => 3)}"
+          - asset.versions_info.each do |version, attributes|
+            %br
+            = link_to "#{version.to_s.gsub('_',' ').titleize}", assets_image_url(asset, version), :class => 'asset-insertable', :data => {'asset-id' => asset.id, 'asset' => assets_image_tag(asset, version) }
+            = "#{attributes[:width]}x#{attributes[:height]}px #{number_to_human_size(attributes[:data_size], :precision => 3)}"
+        - elsif asset.icon?
+          = link_to asset.file_name, asset.image, :class => 'asset-insertable', :data => {'asset-id' => asset.id, 'asset' => effective_asset_image_tag(asset)}
+          = "#{number_to_human_size(asset.data_size, :precision => 3)}"
+        - elsif asset.video?
+          = link_to asset.file_name, asset.url, :class => 'asset-insertable', :data => {'asset-id' => asset.id, 'asset' => effective_asset_video_tag(asset)}
+          = "#{number_to_human_size(asset.data_size, :precision => 3)}"
+        - else
+          = link_to asset.file_name, asset.url, :class => 'asset-insertable', :data => {'asset-id' => asset.id, 'asset' => effective_asset_link_to(asset)}
+          = "#{number_to_human_size(asset.data_size, :precision => 3)}"
+
+  = f.actions :submit, :cancel

data/app/views/active_admin/effective_assets/_form.html.haml

@@ -0,0 +1,4 @@
+- if @effective_asset.new_record?
+  = render :partial => 'active_admin/effective_assets/new', :locals => {:asset => @effective_asset}
+- else
+  = render :partial => 'active_admin/effective_assets/edit', :locals => {:asset => @effective_asset}

data/app/views/active_admin/effective_assets/_new.html.haml

@@ -0,0 +1,3 @@
+= semantic_form_for asset, :url => '/' do |f|
+  = f.input :uploads, :as => :asset_box, :uploader => true, :uploader_visible => true
+= link_to 'Back', :back

data/app/views/asset_box_input/_attachment_fields.html.haml

@@ -0,0 +1,14 @@
+- attachable_type ||= attachment.attachable_type.titleize.gsub(" ", "_").gsub('/', '_').downcase
+- uid = (attachment.persisted? ? attachment.id : Time.now.to_i)
+- hidden ||= false
+
+.asset-box-attachment{:style => "#{(attachment.marked_for_destruction? || hidden) ? 'display: none;' : ''}"}
+  - if attachment.persisted?
+    = hidden_field_tag("#{attachable_type}[attachments_attributes][#{uid}][id]", attachment.id)
+  = hidden_field_tag("#{attachable_type}[attachments_attributes][#{uid}][asset_id]", attachment.asset_id)
+  = hidden_field_tag("#{attachable_type}[attachments_attributes][#{uid}][box]", attachment.box)
+  = hidden_field_tag("#{attachable_type}[attachments_attributes][#{uid}][_destroy]", attachment.marked_for_destruction? ? 1 : nil, :class => 'asset-box-remove')
+
+  %span.thumbnail= effective_asset_image_tag(attachment.asset, :thumb)
+  %p.title= attachment.asset.title
+  %a.asset-box-remove{:href => '#'} Delete

data/app/views/asset_box_input/_uploader.html.haml

@@ -0,0 +1,119 @@
+.asset_box_uploader{:style => "#{uploader_visible ? '' : 'display: none;'}"}
+  .file_lists
+    %ul.file_done_list.file_list
+    %ul.file_todo_list.file_list
+  .queue_size
+    %span.numerator
+    %span.denominator
+  .overall
+    %span.progress
+      %span.amount
+    %span.status
+
+  %script{:type => 'text/javascript'}
+    :erb
+
+      $("div.asset_box_input[data-swf='s3_swf_<%= uid %>'][data-mode='multiple']").find('div.attachments').first().sortable();
+      preload_spinner = new Image();
+      preload_spinner.src = '/assets/effective_assets/spinner.gif';
+
+      var s3_swf_<%= uid %>_object = s3_swf_init('s3_swf_<%= uid %>', {
+        buttonWidth: 100,
+        buttonHeight: 30,
+        flashVersion: '9.0.0',
+        queueSizeLimit: <%= limit %>,
+        fileSizeLimit: 524288000,
+        fileTypes: '<%= file_types.present? ? file_types.map { |t| "*.#{t.to_s}"}.join(';') : '*.*' %>',
+        fileTypeDescs: 'Uploadable Files',
+        selectMultipleFiles: <%= limit > 1 ? 'true' : 'false' %>,
+        keyPrefix: '<%= "#{EffectiveAssets.aws_upload_path.chomp('/')}" + '/' %>',
+        signaturePath: '/s3_uploads.xml',
+        swfFilePath: '/assets/effective_assets/s3_upload.swf',
+        buttonUpPath: '/assets/effective_assets/s3_up_button.gif',
+        buttonOverPath: '/assets/effective_assets/s3_over_button.gif',
+        buttonDownPath: '/assets/effective_assets/s3_down_button.gif',
+        swfVarObj: 's3_swf_<%= uid %>_object',
+          onFileSizeLimitReached: function(file) {
+            alert('That file is too big');
+          },
+          onQueueSizeLimitReached: function(queue) {
+            alert('There are too many files in the queue');
+          },
+          onQueueEmpty: function(queue) {
+            alert('You gotta have at least one file in there');
+          },
+          onSignatureSecurityError: function(file,security_error_event) {
+            alert('There was an error');
+          },
+          onSignatureIOError: function(file,io_error_event) {
+            alert('There was an error');
+          },
+          onSignatureXMLError: function(file,error_message) {
+            alert('There was an error');
+          },
+          onUploadError: function(upload_options,error) {
+            alert('There was an error');
+          },
+          onUploadIOError: function(upload_options,io_error_event) {
+            alert('There was an error');
+          },
+          onUploadSecurityError: function(upload_options,security_error_event) {
+            alert('There was an error');
+          },
+          onQueueClear: function(queue) {
+            s3_queueClearHandler('s3_swf_<%= uid %>', queue);
+          },
+          onUploadingFinish: function() {
+            s3_uploadingFinishHandler('s3_swf_<%= uid %>');
+          },
+          onUploadingStart: function() {
+            s3_uploadingStartHandler('s3_swf_<%= uid %>');
+          },
+          onQueueChange: function(queue) {
+            s3_queueChangeHandler('s3_swf_<%= uid %>', queue);
+          },
+          onUploadProgress: function(upload_options,progress_event) {
+            s3_progressHandler('s3_swf_<%= uid %>', progress_event);
+          },
+          onUploadComplete: function(upload_options,event) {
+            var obj         = $("div.asset_box_input[data-swf='s3_swf_<%= uid %>']").find('div.asset_box_uploader').first();
+            var one_file    = obj.find('.file_todo_list').find("li.file_to_upload").first()
+            var title       = one_file.find('input.title').val();
+            var description = one_file.find('input.description').val();
+            var tags        = one_file.find('input.tags').val();
+
+            s3_addFileToDoneList('s3_swf_<%= uid %>', upload_options.FileName, upload_options.FileSize);
+
+            $.ajax({
+              url: '<%= s3_uploads_path %>',
+              beforeSend: function(jqXHR, settings) {
+                s3_showAttachmentLoading('s3_swf_<%= uid %>', title);
+              },
+              complete: function(jqXHR, textStatus) {
+                s3_loadAttachmentHtml('s3_swf_<%= uid %>', jqXHR.responseText);
+              },
+              global: false,
+              type: 'POST',
+              dataType: 'script',
+              data: {
+                'authenticity_token' : '<%= form_authenticity_token %>',
+                'file_name' : upload_options.FileName,
+                'file_path' : upload_options.key,
+                'file_size' : upload_options.FileSize,
+                'box'       : '<%= box %>',
+                'attachable_type' : '<%= attachable_type %>',
+                'attachable_id' : '<%= attachable_id %>',
+                'content_type' : upload_options.ContentType,
+                'title' : title,
+                'description' : description,
+                'tags' : tags
+              }
+            })
+          }
+        });
+  %div{:id => "s3_swf_#{uid}"}
+
+  %div
+    %input.StartButton{:onclick => "s3_swf_#{uid}_object.startUploading(); return false;", :type => "submit", :value => "Start Uploading"}
+    %input.ResetButton{:onclick => "s3_swf_#{uid}_object.clearQueue(); return false;", :type => "submit", :value => "Clear Queue"}
+    %input.StopButton{:onclick => "s3_swf_#{uid}_object.stopUploading(); return false;", :type => "submit", :value => "Stop Uploading"}

data/app/views/assets/_video.html.erb

@@ -0,0 +1,4 @@
+<video id='video_asset_<%= asset.id %>' class='video-js vjs-default-skin' controls preload='auto' data-setup='{}'>
+  <source src='<%= asset.url %>' type='video/mp4'>
+</video>
+

data/config/routes.rb

@@ -0,0 +1,6 @@
+Rails.application.routes.draw do
+  scope :module => 'effective' do
+    resources :attachments, :only => [:show]
+    resources :s3_uploads, :only => [:index, :create]
+  end
+end

data/db/migrate/01_create_effective_assets.rb.erb

@@ -0,0 +1,42 @@
+class CreateEffectiveAssets < ActiveRecord::Migration
+  def self.up
+    create_table <%= @assets_table_name %> do |t|
+      t.string  :title
+      t.text    :description
+      t.string  :tags
+
+      t.integer :user_id
+
+      t.string  :content_type
+      t.string  :upload_file
+      t.string  :data
+      t.boolean :processed, :default => false
+
+      t.integer :data_size
+      t.integer :height
+      t.integer :width
+      t.text    :versions_info
+
+      t.timestamps
+    end
+
+    add_index <%= @assets_table_name %>, :content_type
+
+    create_table <%= @attachments_table_name %> do |t|
+      t.integer :asset_id
+      t.string  :attachable_type
+      t.integer :attachable_id
+      t.integer :position
+      t.string  :box
+    end
+
+    add_index <%= @attachments_table_name %>, :asset_id
+    add_index <%= @attachments_table_name %>, [:attachable_type, :attachable_id]
+    add_index <%= @attachments_table_name %>, :attachable_id
+  end
+
+  def self.down
+    drop_table <%= @assets_table_name %>
+    drop_table <%= @attachments_table_name %>
+  end
+end

data/lib/effective_assets.rb

@@ -0,0 +1,31 @@
+require "effective_assets/engine"
+require 'carrierwave'
+require 'delayed_job_active_record'
+require 'migrant'     # Required for rspec to run properly
+
+module EffectiveAssets
+  # The following are all valid config keys
+  mattr_accessor :assets_table_name
+  mattr_accessor :attachments_table_name
+
+  mattr_accessor :uploader
+
+  mattr_accessor :aws_bucket
+  mattr_accessor :aws_access_key_id
+  mattr_accessor :aws_secret_access_key
+
+  mattr_accessor :aws_upload_path  # This directory is where the flash s3 uploader first places files
+  mattr_accessor :aws_final_path # We then authenticate and use Fog to copy the object from upload_path to final_path
+  mattr_accessor :aws_acl
+
+  mattr_accessor :authorization_method
+
+  def self.setup
+    yield self
+  end
+
+  def self.authorized?(controller, action, resource)
+    raise ActiveResource::UnauthorizedAccess.new('') unless (controller || self).instance_exec(controller, action, resource, &EffectiveAssets.authorization_method)
+    true
+  end
+end

data/lib/effective_assets/engine.rb

@@ -0,0 +1,38 @@
+module EffectiveAssets
+  class Engine < ::Rails::Engine
+    engine_name 'effective_assets'
+
+    config.autoload_paths += Dir["#{config.root}/app/models/concerns"]
+    config.autoload_paths += Dir["#{config.root}/app/models/inputs"]
+    config.autoload_paths += Dir["#{config.root}/app/models/validators"]
+    config.autoload_paths += Dir["#{config.root}/app/models/uploaders"]
+
+    # Include Helpers to base application
+    initializer 'effective_assets.action_controller' do |app|
+      ActiveSupport.on_load :action_controller do
+        helper EffectiveAssetsHelper
+      end
+    end
+
+    # Include acts_as_addressable concern and allow any ActiveRecord object to call it
+    initializer 'effective_assets.active_record' do |app|
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Base.extend(ActsAsAssetBox::ActiveRecord)
+      end
+    end
+
+    # Set up our default configuration options.
+    initializer "effective_assets.defaults", :before => :load_config_initializers do |app|
+      eval File.read("#{config.root}/lib/generators/templates/effective_assets.rb")
+    end
+
+    # ActiveAdmin (optional)
+    # This prepends the load path so someone can override the assets.rb if they want.
+    initializer 'effective_assets.active_admin' do
+      if defined?(ActiveAdmin)
+        ActiveAdmin.application.load_paths.unshift Dir["#{config.root}/active_admin"]
+      end
+    end
+
+  end
+end

data/lib/effective_assets/version.rb

@@ -0,0 +1,3 @@
+module EffectiveAssets
+  VERSION = "0.1"
+end

data/lib/generators/effective_assets/install_generator.rb

@@ -0,0 +1,41 @@
+module EffectiveAssets
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      desc "Creates an EffectiveAssets initializer in your application."
+
+      source_root File.expand_path("../../templates", __FILE__)
+
+      def self.next_migration_number(dirname)
+        if not ActiveRecord::Base.timestamped_migrations
+          Time.new.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+
+      def copy_initializer
+        template "effective_assets.rb", "config/initializers/effective_assets.rb"
+      end
+
+      def copy_uploader
+        template "asset_uploader.rb", "app/uploaders/asset_uploader.rb"
+      end
+
+      def create_migration_file
+        @assets_table_name = ':' + EffectiveAssets.assets_table_name.to_s
+        @attachments_table_name = ':' + EffectiveAssets.attachments_table_name.to_s
+        migration_template '../../../db/migrate/01_create_effective_assets.rb.erb', 'db/migrate/create_effective_assets.rb'
+      end
+
+      def install_delayed_jobs
+        run "rails generate delayed_job:active_record"
+      end
+
+      def show_readme
+        readme "README" if behavior == :invoke
+      end
+    end
+  end
+end