balloon 1.0.0

data/lib/balloon/processing.rb

@@ -0,0 +1,98 @@
+require 'mini_magick'
+
+module Balloon
+  module Processing
+    extend ActiveSupport::Concern
+
+    def resize_with_string(file)
+      width, height = "", ""
+      oranginl_img = MiniMagick::Image.open(file.path)
+      auto_orient!(oranginl_img, file.path)
+      if self.respond_to?(:uploader_size) && !(store_storage.to_s == "upyun" && upyun_is_image)
+        uploader_size.each do |s, o|
+          img = MiniMagick::Image.open(file.path)
+          raise ProcessError, "process error" unless img
+          width = img[:width]
+          height = img[:height]
+          new_img = resize(img, o)
+          new_img.write File.join(cache_path, "#{file.basename}_#{s}.#{file.extension}")
+        end
+      end
+      return {width: oranginl_img[:width], height: oranginl_img[:height]}
+    end
+
+    def resize(image, size)
+      width, height, symbol = size[:width], size[:height], size[:symbol]     
+      if !symbol.empty? || width.match(/\%/) || height.match(/\%/)
+        if width == height
+          image = shave(image)
+          image.resize "#{width}"
+        else
+          image.resize "#{width}x#{height}#{symbol}"
+        end
+      else
+        if width == height
+          image = shave(image)
+          value = (width.to_f / image[:width].to_f) * 100
+          image.resize "#{value}%"
+        else
+          if width.empty?
+            value = (height.to_f / image[:height].to_f)  * 100
+            image.resize "#{value}%"
+          elsif height.empty?
+            value = (width.to_f / image[:width].to_f)  * 100
+            image.resize "#{value}%"
+          else
+            image.resize "#{width}x#{height}"
+          end
+        end
+      end
+      return image
+    end
+
+    def shave(image)
+      w, h = image[:width], image[:height]
+      if w > h
+        shave_off = ((w - h) / 2).round
+        image.shave "#{shave_off}x0"
+      else
+        shave_off = ((h - w) / 2).round
+        image.shave "0x#{shave_off}"
+      end 
+      return image
+    end
+
+    def auto_orient!(img, file)
+      if img["exif:orientation"] == "6"
+        img.auto_orient
+        img.write file
+      end
+    end
+
+    # parseing the size string
+    #
+    # @return [Hash] the options for string
+    module ClassMethods
+      def parsing_size_string(size)
+        symbol = ""
+        symbol_regex = /[^\d|\!|\>|\<|\%|x|X]/
+          if size.include?('x')
+            if has_symbol = size.match(/[\!|\>|\<]/)
+              symbol = has_symbol[0]
+              size_option = size[0, 7].split("x")
+            else
+              size_option = size.split("x")
+            end
+            width, height = size_option
+          else
+            width, height = size, size
+          end
+        width = width || ""
+        width = width.match(symbol_regex) ? "" : width
+        height = height || ""
+        height = height.match(symbol_regex) ?  "" : height
+        return { width: width, height: height, symbol: symbol }
+      end
+    end
+  end
+end

data/lib/balloon/storage/file.rb

@@ -0,0 +1,62 @@
+module Balloon
+  module Storage
+    class File < Balloon::Storage::Store
+      def store!
+        _store_path = store_path
+
+        if !::File.exists? _store_path
+          FileUtils.mkdir_p _store_path
+          FileUtils.chmod_R @uploader.dir_permissions.to_i,  _store_path
+        end
+
+        original_file = set_upload_name
+        store_original_file = ::File.join _store_path, original_file
+        cache_original_file = ::File.join @uploader.cache_path, @uploader.info[:filename]
+        FileUtils.mv cache_original_file, store_original_file
+
+        if @uploader.respond_to?(:uploader_size)
+          @uploader.uploader_size.each do |s, o|
+            store_file = ::File.join _store_path, set_upload_name(s)
+            cache_file = ::File.join @uploader.cache_path, @uploader.info[:basename]+ "_#{s}"+"."+ @uploader.info[:extension]
+            FileUtils.mv cache_file, store_file
+          end
+        end
+        return { filename: original_file, basename: store_name}
+      end
+
+      def retrieve!(size_name = nil)
+        return "" if !upload_file
+        path = ::File.join upload_dir, store_filename(size_name)
+        return "/" + path if @uploader.asset_host.nil?
+        @uploader.asset_host + "/" + path
+      end
+
+      def delete!
+        return false if !upload_file
+        path = ::File.join store_path, store_filename
+        FileUtils.rm(path) if ::File.exists?(path)
+        if @uploader.respond_to?(:uploader_size)
+          @uploader.uploader_size.each do |s, o|
+            path = ::File.join store_path, store_filename(s)
+            FileUtils.rm(path) if ::File.exists?(path)
+          end
+        end
+      end
+
+      private
+
+      def store_filename(size_name = nil)
+        extension = upload_file[:extension].blank? ? "" : "." + upload_file[:extension]
+        if size_name.nil?
+          upload_file[:basename] + extension
+        else
+          upload_file[:basename] + "_" + size_name.to_s + extension
+        end
+      end
+
+      def store_path
+        ::File.expand_path ::File.join(@uploader.root, @uploader.store_dir, upload_dir)
+      end
+    end
+  end
+end

data/lib/balloon/storage/store.rb

@@ -0,0 +1,84 @@
+module Balloon
+  module Storage
+    class Store
+      def initialize(uploader)
+        @uploader = uploader
+      end
+
+      def store!; end
+
+      def retrieve!(size_name = nil); end
+
+      def upload_file
+        file_info = @uploader.info
+        return {} if file_info.nil?
+        basename = file_info[:basename] || ""
+        extension = file_info[:extension] || ""
+        { basename: basename, extension: extension }
+      end
+
+      def upload_dir
+        @uploader.respond_to?(:uploader_dir) ? @uploader.uploader_dir : @uploader.uploader_name
+      end
+
+      def store_name
+        return upload_file[:basename] if !@uploader.respond_to?(:uploader_name_format) 
+        name_format = @uploader.uploader_name_format
+        name = name_format[:name]
+        if name_format[:format].to_s == "downcase" 
+          name = name.downcase
+        elsif name_format[:format].to_s == "upcase"
+          name = name.upcase
+        else
+          name
+        end
+      end
+
+      def set_upload_name(size_name = nil )
+        if size_name 
+          store_name + "_#{size_name.to_s}" + "." + upload_file[:extension] 
+        else
+          store_name + "." + upload_file[:extension] 
+        end
+      end
+
+      def connection
+        options = self.class.get_option(self)
+        basic = self.class.get_basic_auth(self)
+        token = self.class.token_auth
+        conn = Http::Client.new(options[:url]) do |builder|
+          builder.headers = options[:headers]
+          builder.basic_auth(basic[:user], basic[:password]) if !basic.nil?
+          builder.token_auth(self, token) if !token.nil? 
+        end
+        return conn
+      end
+
+      class << self
+        def conn_option(&block)
+          return @option_proc unless block_given?
+          @option_proc = block
+        end
+
+        def get_option(klass)
+          klass.instance_eval(&conn_option)
+        end
+
+        def basic_auth(&block)
+          return @basic_proc unless block_given?
+          @basic_proc = block
+        end
+
+        def get_basic_auth(klass)
+          return nil if basic_auth.nil?
+          klass.instance_eval(&basic_auth)
+        end
+
+        def token_auth(&block)
+          return @token_proc unless block_given?
+          @token_proc = block
+        end
+      end
+    end
+  end
+end

data/lib/balloon/storage/upyun.rb

@@ -0,0 +1,91 @@
+module Balloon
+  module Storage
+    class Upyun < Balloon::Storage::Store
+
+      conn_option do
+        {
+          url: conn_url,
+          headers: conn_headers,
+          timeout: @uploader.upyun_timeout
+        }
+      end
+
+      token_auth do |method, path, size, date|
+        "encode_canonical('#{method}', '#{path}', #{size}, '#{date}')" 
+      end
+
+      def store!
+        _store_path = store_path
+        original_file = set_upload_name
+        store_original_file = ::File.join _store_path, original_file       
+        cache_original_file = ::File.join @uploader.cache_path, @uploader.info[:filename]
+        file = ::File.new cache_original_file
+        response = connection.put(store_original_file, file.read, file.size)
+        raise "Connection errors" if response.nil?
+
+        if !@uploader.upyun_is_image && @uploader.respond_to?(:uploader_size)
+          @uploader.uploader_size.each do |s, o|
+            store_file = ::File.join _store_path, set_upload_name(s)
+            cache_file = ::File.join @uploader.cache_path, @uploader.info[:basename]+ "_#{s}"+"."+ @uploader.info[:extension]
+            file = ::File.new cache_file
+            connection.put(store_file, file.read, file.size)
+          end
+        end
+
+        return { filename: original_file, basename: store_name }
+      end
+
+      def retrieve!(size_name = nil)
+        if !@uploader.upyun_is_image || size_name.nil?
+          path = ::File.join upload_dir, store_filename(size_name)
+          @uploader.upyun_domain + "/" + path
+        else
+          filename = store_filename + @uploader.upyun_thumb_symbol + size_name.to_s
+          path = ::File.join upload_dir, filename
+          @uploader.upyun_domain + "/" + path
+        end
+      end
+
+      def delete!
+        _store_path = store_path
+        store_original_file = ::File.join _store_path, store_filename
+        response = connection.delete(store_original_file)
+        if !@uploader.upyun_is_image && @uploader.respond_to?(:uploader_size)
+          @uploader.uploader_size.each do |s, o|
+            store_file = ::File.join _store_path, store_filename(s)
+            connection.delete(store_file)
+          end
+        end
+      end
+
+      private
+
+      def encode_canonical(method, path, size, date)
+        options = []
+        options << method
+        options << path 
+        options << date
+        options << size 
+        options << "#{Digest::MD5.hexdigest(@uploader.upyun_password)}"
+        "UpYun #{@uploader.upyun_username}:#{Digest::MD5.hexdigest(options.join("&"))}"
+      end
+
+      def store_filename(size_name = nil)
+        return upload_file[:basename] + "." + upload_file[:extension] if size_name == nil
+        upload_file[:basename] + "_" + size_name.to_s + "." + upload_file[:extension]
+      end
+
+      def conn_url
+        @uploader.upyun_api_host || "http://v0.api.upyun.com"
+      end
+
+      def conn_headers
+        @uploader.upyun_headers.merge({ 'Mkdir' => 'true', 'Expect' => '', 'Date' => Time.now.httpdate })
+      end
+
+      def store_path
+        ::File.join("/", @uploader.upyun_bucket, upload_dir)
+      end
+    end
+  end
+end

data/lib/balloon/up.rb

@@ -0,0 +1,100 @@
+module Balloon
+  module Up
+    extend ActiveSupport::Concern
+
+    included do
+      include Balloon::Uploader
+      include Balloon::Validate
+    end
+
+    module ClassMethods
+      def uploader(name, db = nil)
+
+        before_create :uploader_save
+
+        class_eval <<-RUBY
+          def #{name}=(file)
+            save_to_cache(file)
+          rescue DownloadError => e
+            @download_error = e
+          rescue ProcessError => e
+            @process_error = e
+          end
+
+          def #{name}
+            @info
+          end
+
+          def uploader_save
+            return if info.nil?
+            set_storage_engine
+            store_info = storage_engine.store!
+            @info[:filename] = store_info[:filename]
+            @info[:basename] = store_info[:basename]
+          end
+
+          def uploader_name
+            "#{name}".pluralize
+          end
+        RUBY
+
+        set_keyword if db
+
+        validates_download_of name
+      end
+
+      def set_keyword
+        if defined?(MongoMapper)
+          key :file_name, String
+          key :width, Integer
+          key :height, Integer
+          key :content_type, String
+          key :file_size, Integer
+          key :storage, String
+          key :created_at
+        elsif defined?(Mongoid)
+          field :file_name, type: String
+          field :width, type: Integer
+          field :height, type: Integer
+          field :content_type, type: String
+          field :file_size, type: String
+          field :storage, type: String
+          field :created_at
+        end
+
+        before_create :save_db
+        after_destroy :uploader_delete
+
+        class_eval <<-RUBY
+          def save_db
+            return if info.nil?
+            self.file_name = info[:filename]
+            self.content_type = info[:mime_type]
+            self.file_size = info[:size]
+            self.storage = store_storage.to_s
+            self.width = info[:width]
+            self.height = info[:height]
+          end
+
+          def url(size_name = nil)
+           return "" if !respond_to?(:file_name) || file_name.nil?
+           extension = self.file_name.to_s.match(%r"(?!\\.{1})\\w{2,}$")
+           basename = self.file_name.to_s.gsub(%r"\\.{1}\\w{2,}$",'')
+           @info = { basename: basename, extension: extension.to_s }
+           set_storage_engine
+           storage_engine.retrieve!(size_name)
+          end
+
+          def uploader_delete
+           return if !respond_to?(:file_name) || file_name.nil?
+           extension = self.file_name.to_s.match(%r"(?!\\.{1})\\w{2,}$")
+           basename = self.file_name.to_s.gsub(%r"\\.{1}\\w{2,}$",'')
+           @info = { basename: basename, extension: extension.to_s }
+           set_storage_engine
+           storage_engine.delete!
+          end
+        RUBY
+      end
+    end #ClassMethods
+  end #Up
+end

data/lib/balloon/uploader.rb

@@ -0,0 +1,90 @@
+module Balloon
+  module Uploader
+    extend ActiveSupport::Concern
+
+    included do
+      include Balloon::Configuration
+      include Balloon::Processing
+      include Balloon::Cache
+      include Balloon::Download
+      attr_accessor :file
+      attr_reader :storage_engine
+      attr_reader :info
+      attr_accessor :download_error, :process_error
+    end
+
+    def set_storage_engine
+      @storage_engine = eval(Balloon::Base::STORAGE_EGINE[store_storage.to_sym]).new(self) if !respond_to?(:@storage_engine)
+    end
+
+    def save_to_cache(up_file)
+      uploader_file = up_file.is_a?(String) && up_file.include?("://") ? down_url(up_file) : up_file
+
+      uploader_file_ext = Balloon::FileExtension.new(uploader_file)
+      file_mime_type = uploader_file_ext.mime_type
+
+      if self.respond_to?(:uploader_mimetype_white)
+        if !uploader_mimetype_white.include?(file_mime_type)          
+          raise Balloon::DownloadError, I18n.translate(:"errors.messages.down_mime_error")
+        end
+      elsif self.respond_to?(:uploader_mimetype_black)
+        if !uploader_mimetype_black.include?(file_mime_type)          
+          raise Balloon::DownloadError, I18n.translate(:"errors.messages.down_mime_error")
+        end
+      end
+
+      generate_cache_directory
+      up_file = uploader_file_ext.save_to cache_path, permissions
+      uploader_file = up_file
+      img = resize_with_string up_file
+      @info = { 
+        width: img[:width],
+        height: img[:height],
+        size: up_file.size,
+        mime_type: up_file.mime_type,
+        filename: up_file.filename,  
+        basename: up_file.basename,
+        extension: up_file.extension 
+      }
+    end
+
+    def url(size_name = nil); end
+
+    module ClassMethods
+      def uploader_dir(name)
+        define_method "uploader_dir" do; name; end
+      end
+
+      def uploader_size(options)
+        list = {}
+
+        if options.is_a?(Hash)
+          options.each do |key, value|
+            list[key] = parsing_size_string(value)
+          end
+        else
+          list[:orignal] = parsing_size_string options
+        end
+
+        define_method "uploader_size" do; list; end
+      end
+
+      def uploader_name_format(info)
+        define_method "uploader_name_format" do
+          name = info[:name].nil? ? info[:name] : info[:name].call(self)
+          { name: name, format: info[:format] }
+        end
+      end
+
+      def uploader_mimetype_white(list)
+        raise "just choise one method" if respond_to?(:uploader_mime_type_black)
+        define_method "uploader_mimetype_white" do; list; end
+      end
+
+      def uploader_mimetype_black(list)
+        raise "just choise one method" if respond_to?(:uploader_mime_type_black)
+        define_method "uploader_mimetype_black" do; list; end
+      end
+    end
+  end #Uploader
+end