fogged 0.0.2

data/app/models/fogged/resources/aws_encoder.rb

@@ -0,0 +1,64 @@
+module Fogged
+  module Resources
+    class AWSEncoder < Struct.new(:resource)
+      def encode!
+        encode_video if resource.video?
+      end
+
+      private
+
+      def encode_video
+        fail(ArgumentError, "Zencoder gem needed") unless defined?(Zencoder)
+        fail(ArgumentError, "Delayed Job gem needed") unless defined?(Delayed::Job)
+
+        job = Zencoder::Job.create(
+          :input => resource.url,
+          :region => "europe",
+          :download_connections => 5,
+          :output => output
+        )
+        resource.update!(
+          :encoding_job_id => job.body["id"].to_s,
+          :encoding_progress => 0
+        )
+
+        Delayed::Job.enqueue(ZencoderPollJob.new(resource.id))
+      end
+
+      def output
+        [
+          {
+            :url => "s3://#{bucket}/#{fogged_name_for(:h264)}",
+            :video_codec => "h264",
+            :public => 1,
+            :thumbnails => {
+              :number => 5,
+              :format => "png",
+              :base_url => "s3://#{bucket}",
+              :filename => "#{resource.token}-thumbnail-{{number}}",
+              :public => 1
+            }
+          },
+          {
+            :url => "s3://#{bucket}/#{fogged_name_for(:mpeg)}",
+            :video_codec => "mpeg4",
+            :public => 1
+          },
+          {
+            :url => "s3://#{bucket}/#{fogged_name_for(:webm)}",
+            :video_codec => "vp8",
+            :public => 1
+          }
+        ]
+      end
+
+      def bucket
+        resource.send(:fogged_file).directory.key
+      end
+
+      def fogged_name_for(type)
+        resource.send(:fogged_name_for, type)
+      end
+    end
+  end
+end

data/app/models/fogged/resources/encoder.rb

@@ -0,0 +1,13 @@
+module Fogged
+  module Resources
+    class Encoder
+      def self.for(resource)
+        "Fogged::Resources::#{provider_for(resource)}Encoder".constantize.new(resource)
+      end
+
+      def self.provider_for(resource)
+        return :AWS if resource.send(:fogged_file).class.to_s.include?("AWS")
+      end
+    end
+  end
+end

data/app/serializers/fogged/resource_serializer.rb

@@ -0,0 +1,35 @@
+module Fogged
+  class ResourceSerializer < ActiveModel::Serializer
+    attributes :id, :name, :upload_url, :url
+    attributes :h264_url, :mpeg_url, :webm_url, :thumbnail_urls
+    attributes :encoding_progress
+
+    def include_upload_url?
+      options[:include_upload_url]
+    end
+
+    def include_h264_url?
+      object.video?
+    end
+
+    def include_mpeg_url?
+      object.video?
+    end
+
+    def include_webm_url?
+      object.video?
+    end
+
+    def include_thumbnail_urls?
+      object.video?
+    end
+
+    def include_encoding_progress?
+      object.video?
+    end
+
+    def encoding_progress
+      object.encoding_progress || 0
+    end
+  end
+end

data/config/locales/en.yml

@@ -0,0 +1,6 @@
+en:
+  fogged:
+    resource:
+      still_uploading: is still uploading, please confirm it first
+    resources:
+     still_uploading: are still uploading, please confirm them first

data/config/locales/fr.yml

@@ -0,0 +1,6 @@
+en:
+  fogged:
+    resource:
+      still_uploading: est en cours d'upload, confirmez la resource!
+    resources:
+     still_uploading: sont en cours d'upload, confirmez les resources!

data/config/routes.rb

@@ -0,0 +1,4 @@
+Fogged::Engine.routes.draw do
+  resources :resources
+  put "resources/:id/confirm" => "resources#confirm"
+end

data/db/migrate/20141103143408_create_fogged_resources.rb

@@ -0,0 +1,20 @@
+class CreateFoggedResources < ActiveRecord::Migration
+  def change
+    create_table :fogged_resources do |t|
+      t.string :name, :null => false
+      t.string :token, :null => false
+      t.integer :width
+      t.integer :height
+      t.string :extension, :null => false
+      t.boolean :uploading
+      t.string :content_type, :null => false
+      t.integer :encoding_progress
+      t.string :encoding_job_id
+      t.integer :duration
+
+      t.timestamps
+    end
+
+    add_index :fogged_resources, :token
+  end
+end

data/lib/fogged.rb

@@ -0,0 +1,46 @@
+Gem.loaded_specs["fogged"].dependencies.select { |d| d.type == :runtime }.each do |d|
+  require d.name
+end
+
+require "fogged/engine"
+require "fogged/acts_as_having_one_resource"
+require "fogged/acts_as_having_many_resources"
+
+module Fogged
+  mattr_accessor :provider
+  @@provider = nil
+
+  mattr_accessor :resources
+  @@resources = nil
+
+  mattr_accessor :test_enabled
+  @@test_enabled = false
+
+  # controller
+  mattr_accessor :parent_controller
+  @@parent_controller = "ApplicationController"
+
+  # aws
+  mattr_accessor :aws_key
+  @@aws_key = nil
+  mattr_accessor :aws_secret
+  @@aws_secret = nil
+  mattr_accessor :aws_bucket
+  @@aws_bucket = nil
+  mattr_accessor :aws_region
+  @@aws_region = nil
+
+  # zencoder
+  mattr_accessor :zencoder_enabled
+  @@zencoder_enabled = false
+  mattr_accessor :zencoder_polling_frequency
+  @@zencoder_polling_frequency = 10
+
+  def self.configure
+    yield self
+  end
+
+  def self.test_mode!
+    self.test_enabled = true
+  end
+end

data/lib/fogged/acts_as_having_many_resources.rb

@@ -0,0 +1,30 @@
+module Fogged
+  module ActsAsHavingManyResources
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      DEFAULT_OPTIONS = {
+        :dependent => :destroy,
+        :class_name => "Fogged::Resource"
+      }
+
+      def acts_as_having_many_resources(*args)
+        options = args.extract_options!
+        unless options.include?(:through)
+          fail(ArgumentError, ":through option is mandatory")
+        end
+        has_many :resources, DEFAULT_OPTIONS.merge(options)
+        validate :_check_resources, :unless => "resources.empty?"
+      end
+    end
+
+    private
+
+    def _check_resources
+      return if resources.to_a.select(&:uploading).empty?
+      errors.add(:resources, I18n.t("fogged.resources.still_uploading"))
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Fogged::ActsAsHavingManyResources)

data/lib/fogged/acts_as_having_one_resource.rb

@@ -0,0 +1,34 @@
+module Fogged
+  module ActsAsHavingOneResource
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      DEFAULT_OPTIONS = {
+        :dependent => :destroy,
+        :class_name => "Fogged::Resource"
+      }
+
+      def acts_as_having_one_resource(*args)
+        belongs_to :resource, DEFAULT_OPTIONS.merge(args.extract_options!)
+        validate :_check_resource, :unless => "resource.blank?"
+
+        define_method(:resource_id) do
+          resource.try(:id)
+        end
+
+        define_method(:resource_id=) do |id|
+          self.resource = id.blank? ? nil : Resource.find(id)
+        end
+      end
+    end
+
+    private
+
+    def _check_resource
+      return unless resource.uploading
+      errors.add(:resource, I18n.t("fogged.resource.still_uploading"))
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Fogged::ActsAsHavingOneResource)

data/lib/fogged/engine.rb

@@ -0,0 +1,50 @@
+module Fogged
+  class Engine < ::Rails::Engine
+    isolate_namespace Fogged
+    config.fogged = Fogged
+
+    initializer "fogged.detect_zencoder" do
+      if defined?(Zencoder) && defined?(Delayed::Job)
+        Fogged.zencoder_enabled = true
+      end
+    end
+
+    initializer "fogged.resources" do
+      unless Fogged.test_enabled
+        case Fogged.provider
+        when :aws
+          fail(ArgumentError, "AWS key is mandatory") unless Fogged.aws_key
+          fail(ArgumentError, "AWS secret is mandatory") unless Fogged.aws_secret
+          fail(ArgumentError, "AWS bucket is mandatory") unless Fogged.aws_bucket
+          storage_options = {
+            :provider => "AWS",
+            :aws_access_key_id => Fogged.aws_key,
+            :aws_secret_access_key => Fogged.aws_secret
+          }
+          storage_options.merge!(:region => Fogged.aws_region) if Fogged.aws_region
+          storage = Fog::Storage.new(storage_options)
+
+          Fogged.resources = storage.directories.get(Fogged.aws_bucket)
+          if Rails.env.test?
+            Fog.mock!
+            Fogged.resources = storage.directories.create(:key => Fogged.aws_bucket)
+          end
+        else
+          fail(ArgumentError, "Provider #{Fogged.config.provider} is not available!")
+        end
+      end
+    end
+
+    initializer "fogged.resources.test" do
+      if Fogged.test_enabled
+        Fog.mock!
+        storage = Fog::Storage.new(
+          :provider => "AWS",
+          :aws_access_key_id => "1234567890",
+          :aws_secret_access_key => "1234567890"
+        )
+        Fogged.resources = storage.directories.create(:key => "test")
+      end
+    end
+  end
+end

data/lib/fogged/version.rb

@@ -0,0 +1,3 @@
+module Fogged
+  VERSION = "0.0.2"
+end

data/lib/tasks/fogged_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :fogged do
+#   # Task goes here
+# end

data/test/controllers/fogged/resources_controller/confirm_test.rb

@@ -0,0 +1,56 @@
+require "test_helper"
+
+module Fogged
+  class ResourcesControllerConfirmTest < ActionController::TestCase
+    tests ResourcesController
+    include ResourceTestHelper
+
+    test "should confirm resource" do
+      resource = fogged_resources(:resource_png)
+      FastImage.expects(:size).once.returns([800, 600])
+
+      put :confirm, :id => resource, :use_route => :fogged
+
+      assert_json_resource(resource.reload)
+      assert_equal 800, resource.width
+      assert_equal 600, resource.height
+      refute resource.encoding?
+    end
+
+    test "should confirm video resource with zencoder enabled" do
+      in_a_fork do
+        require "zencoder"
+        require "delayed_job_active_record"
+
+        Fogged.zencoder_enabled = true
+
+        Zencoder::Job.expects(:create).returns(
+          OpenStruct.new(:body => create_output)
+        )
+        resource = fogged_resources(:resource_mov)
+
+        assert_difference("Delayed::Job.count") do
+          put :confirm, :id => resource, :use_route => :fogged
+        end
+
+        assert_json_resource(resource.reload)
+        assert resource.encoding_job_id
+        assert resource.encoding?
+      end
+    end
+
+    test "should not confirm resource with invalid id" do
+      assert_raise(ActiveRecord::RecordNotFound) do
+        put :confirm, :id => 123456, :use_route => :fogged
+      end
+    end
+
+    private
+
+    def create_output
+      {
+        :id => 1234567890
+      }.with_indifferent_access
+    end
+  end
+end

data/test/controllers/fogged/resources_controller/create_test.rb

@@ -0,0 +1,56 @@
+require "test_helper"
+
+module Fogged
+  class ResourcesControllerCreateTest < ActionController::TestCase
+    tests ResourcesController
+    include ResourceTestHelper
+
+    def setup
+      super
+      @resource_params = {
+        :name => "Dummy",
+        :filename => "dummy.png",
+        :content_type => "image/png"
+      }
+    end
+
+    test "should create resource" do
+      assert_difference("Resource.count") do
+        post :create, :resource => @resource_params, :use_route => :fogged
+      end
+
+      assert_json_resource(Resource.last)
+      assert_equal "png", Resource.last.extension
+    end
+
+    test "should not create resource without resource parameter" do
+      assert_no_difference("Resource.count") do
+        assert_raise(ActionController::ParameterMissing) do
+          post :create, :use_route => :fogged
+        end
+      end
+    end
+
+    %i(filename content_type name).each do |field|
+      test "should not create resource without #{field}" do
+        assert_no_difference("Resource.count") do
+          assert_raise(ActionController::ParameterMissing) do
+            post :create,
+                 :resource => @resource_params.merge(field => ""),
+                 :use_route => :fogged
+          end
+        end
+      end
+    end
+
+    test "should not create resource with invalid filename" do
+      assert_no_difference("Resource.count") do
+        assert_raise(ActiveRecord::RecordInvalid) do
+          post :create,
+               :resource => @resource_params.merge(:filename => "bar"),
+               :use_route => :fogged
+        end
+      end
+    end
+  end
+end