quick_file 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+
+*.swp

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in quick_file.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/quick_file/upload.rb

@@ -0,0 +1,260 @@
+module QuickFile
+
+  module Upload
+    extend ActiveSupport::Concern
+
+    ## 
+    #   required fields: id, state, original_filename, styles
+    #   steps
+    #     1. cache
+    #     2. process
+    #     3. store
+
+    STATES = {:loaded => 0, :cached => 1, :processing => 2, :processed => 3, :storing => 4, :stored => 5, :deleted => 6, :error => 7}
+
+    included do
+      cattr_accessor :processes
+      self.processes = {}
+
+    end
+
+    module ClassMethods
+      def add_style(style_name, blk)
+        processes[style_name.to_s] = {:blk => blk}
+      end
+    end
+
+    module InstanceMethods
+      def initialize
+        @file = nil
+        styles = {}
+        errors = []
+      end
+
+      def uploaded_file=(uf)
+        errors = []
+        @file = uf
+        self.original_filename = uf.original_filename
+        self.state = STATES[:loaded]
+        cache!
+      end
+
+      def loaded?
+        self.state == STATES[:loaded]
+      end
+
+      def cached?
+        self.state == STATES[:cached]
+      end
+
+      def processed?
+        self.state == STATES[:processed]
+      end
+
+      def stored?
+        self.state == STATES[:stored]
+      end
+
+      def error?
+        self.state == STATES[:error]
+      end
+
+      def sanitized_basename
+        File.basename original_filename.gsub( /[^a-zA-Z0-9_\-\.]/, '_'), File.extname(original_filename)
+      end
+
+      def sanitized_filename
+        File.basename original_filename.gsub( /[^a-zA-Z0-9_\-\.]/, '_')
+      end
+
+      def extension
+        File.extname(original_filename)
+      end
+
+      def cache!
+        return unless loaded?
+        cp = save_cache_file(QuickFile.generate_cache_name(extension), @file)
+        styles["original"] = {"cache" => cp, 
+                              "ct" => QuickFile.content_type_for(cp),
+                              "sz" => File.size(cp)}
+        self.validate!
+        if errors.size > 0
+          self.state = STATES[:error]
+          File.delete(cp)
+        else
+          self.state = STATES[:cached]
+        end
+        self.save
+      end
+
+      def save_cache_file(cn, file)
+        Dir.mkdir QuickFile::CACHE_DIR unless File.directory?(QuickFile::CACHE_DIR)
+        cp = QuickFile.cache_path(cn)
+        File.open(cp, "wb") { |f| f.write(file.read) }
+        cp
+      end
+
+      def process!
+        return unless cached?
+        self.state = STATES[:processing]
+        save
+        begin
+          puts "#{processes.size} processes"
+          processes.each do |style_name, opts|
+            puts "Processing #{style_name}..."
+            fn = opts[:blk].call(styles["original"]["cache"])
+            unless fn.nil?
+              if (styles.key?(style_name) && !styles[style_name]["cache"].nil?)
+                File.delete(styles[style_name]["cache"])
+              end
+              styles[style_name.to_s] = {"cache" => fn, 
+                                         "ct" => QuickFile.content_type_for(fn),
+                                         "sz" => File.size(fn)}
+            end
+          end
+          self.state = STATES[:processed]
+        rescue StandardError => e
+          puts e.message
+          self.errors << "PROCESS: #{e.message}"
+          self.state = STATES[:error]
+        end
+
+        self.save
+
+        store!
+      end
+
+      def reprocess!
+        return unless (stored? || error?)
+        # download original file
+        cp = QuickFile.new_cache_file File.extname(self.path)
+        QuickFile.download(url, cp)
+        styles["original"] = {"cache" => cp, 
+                              "ct" => QuickFile.content_type_for(cp),
+                              "sz" => File.size(cp)}
+        self.state = STATES[:cached]
+        self.save
+        self.process!
+      end
+
+      def add_file!(style_name, path)
+        styles[style_name.to_s] = {"path" => path}
+        get_style(style_name.to_s)
+        self.state = STATES[:stored]
+        save
+      end
+
+      def path(style_name=nil)
+        style_name ||= :original
+        styles[style_name.to_s]["path"]
+      end
+
+      def content_type(style_name=nil)
+        style_name ||= :original
+        styles[style_name.to_s]["ct"]
+      end
+
+      def size(style_name=nil)
+        style_name ||= :original
+        styles[style_name.to_s]["sz"]
+      end
+
+      def is_image?(style_name=nil)
+        style_name ||= :original
+        return false if content_type(style_name).nil?
+        content_type(style_name).include? "image"
+      end
+
+      def is_video?(style_name=nil)
+        style_name ||= :original
+        fp = styles[style_name]["path"] || styles[style_name]["cache"]
+        QuickFile.is_video_file? fp
+      end
+
+      def style_exists?(style_name)
+        !styles[style_name.to_s].nil?
+      end
+
+      def store!
+        return unless processed?
+        begin
+          styles.keys.each do |style_name|
+            store_style! style_name unless styles[style_name]["cache"].nil?
+          end
+          self.state = STATES[:stored]
+        rescue StandardError => e
+          puts e.message
+          self.errors << "STORE: #{e.message}"
+          if self.errors.count < 5
+            self.store!
+          else
+            self.state = STATES[:error]
+          end
+        end
+        save
+      end
+
+      def storage_protocol
+        case storage_type.to_sym
+        when :s3
+          return :fog
+        when :fog
+          return :fog
+        end
+      end
+
+      def store_style!(style_name)
+        fn = styles[style_name]["cache"]
+        sp = storage_path(style_name, File.extname(fn))
+        if storage_protocol == :fog
+          QuickFile.fog_directory.files.create({
+            :body => File.open(fn).read,
+            :content_type => QuickFile.content_type_for(fn),
+            :key => sp,
+            :public => QuickFile.options[:fog_public]
+          })
+        end
+        styles[style_name]["path"] = sp
+        styles[style_name]["ct"] = QuickFile.content_type_for(fn)
+        styles[style_name]["sz"] = File.size(fn)
+        styles[style_name].delete("cache")
+        File.delete(fn)
+
+        save
+      end
+
+      def get_style(style_name)
+        fn = path(style_name)
+        if storage_protocol == :fog
+          f = QuickFile.fog_directory.files.get(fn)
+          if f.nil?
+            styles[style_name]["ct"] = QuickFile.content_type_for(fn)
+            styles[style_name]["sz"] = 0
+          else
+            styles[style_name]["ct"] = f.content_type.nil? ? QuickFile.content_type_for(fn) : f.content_type
+            styles[style_name]["sz"] = f.content_length
+          end
+          save
+        end
+        f
+      end
+
+      def url(style_name=nil, opts={:secure=>true})
+        proto = opts[:secure] ? "https://" : "http://"
+        style_name ||= "original"
+        return default_url(style_name) unless (styles[style_name] && styles[style_name]["path"])
+        "#{proto}#{QuickFile.host_url[storage_type.to_sym]}#{styles[style_name]["path"]}"
+      end
+
+      def delete
+        # delete uploaded files
+        styles.each do |k,v|
+          QuickFile.fog_directory.files.new(:key => v["path"]).destroy if v["path"]
+          File.delete(v["cache"]) if (v["cache"] && File.exists?(v["cache"]))
+        end
+        self.state = STATES[:deleted]
+      end
+    end
+
+  end
+end

data/lib/quick_file/version.rb

@@ -0,0 +1,3 @@
+module QuickFile
+  VERSION = "0.0.1"
+end

data/lib/quick_file.rb

@@ -0,0 +1,94 @@
+require "quick_file/version"
+require "quick_file/upload"
+require "RMagick"
+
+module QuickFile
+  CACHE_DIR = "/tmp"
+
+  class << self
+    def configure
+      yield options if block_given?
+    end
+
+    def options
+      @@options ||= UPLOAD_OPTIONS
+    end
+
+    def generate_cache_name(ext)
+      "#{SecureRandom.hex(5)}#{ext}"
+    end
+
+    def new_cache_file(ext)
+      QuickFile.cache_path QuickFile.generate_cache_name(ext)
+    end
+
+    def content_type_for(filename)
+      mime = MIME::Types.type_for(filename)[0]
+      return mime.simplified if mime
+      return "application/file"
+    end
+
+    def is_video_file?(filename)
+      filename.downcase.end_with?('.mov', '.3gp', '.wmv', '.m4v', '.mp4')
+    end
+
+    def fog_connection
+      @@fog_connection ||= begin
+        Fog::Storage.new(options[:fog_credentials])
+      end
+    end
+
+    def fog_directory
+      @@fog_directory ||= begin
+          fog_connection.directories.new(
+          :key => options[:fog_directory],
+          :public => options[:fog_public]
+        )
+      end
+    end
+
+    def host_url
+      @@host_url ||= begin
+        {
+          :s3 => "s3.amazonaws.com/#{options[:fog_directory]}/"
+        }
+      end
+    end
+
+    def resize_to_fit(file, x, y)
+      img = Magick::Image.read(file).first
+      nim = img.resize_to_fit x, y
+      outfile = cache_path(generate_cache_name(File.extname(file)))
+      nim.write outfile
+      outfile
+    end
+
+    def resize_to_fill(file, x, y)
+      img = Magick::Image.read(file).first
+      nim = img.resize_to_fill(x, y)
+      outfile = cache_path(generate_cache_name(File.extname(file)))
+      nim.write outfile
+      outfile
+    end
+
+    def cache_path(cn)
+      File.join(CACHE_DIR, cn)
+    end
+
+    def download(url, to)
+      out = open(to, "wb")
+      out.write(open(url).read)
+      out.close
+    end
+
+    def image_from_url(url)
+      open(url, 'rb') do |f|
+        image = Magick::Image.from_blob(f.read).first
+      end
+      image
+    end
+
+
+  end
+
+end

data/quick_file.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "quick_file/version"
+
+Gem::Specification.new do |s|
+  s.name        = "quick_file"
+  s.version     = QuickFile::VERSION
+  s.authors     = ["Alan Graham"]
+  s.email       = ["alangraham5@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A file upload library}
+  s.description = %q{A file upload library for use with MongoDB and S3}
+
+  s.rubyforge_project = "quick_file"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+	s.add_dependency "rmagick"
+	s.add_dependency "fog"
+	s.add_dependency "active_support"
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: quick_file
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alan Graham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-27 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: &70310906168420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70310906168420
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: &70310906168000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70310906168000
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: &70310906167580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70310906167580
+description: A file upload library for use with MongoDB and S3
+email:
+- alangraham5@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/quick_file.rb
+- lib/quick_file/upload.rb
+- lib/quick_file/version.rb
+- quick_file.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: quick_file
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: A file upload library
+test_files: []