balloon 1.0.0

data/lib/balloon/download.rb

@@ -0,0 +1,50 @@
+require 'faraday'
+require 'mime/types'
+
+module Balloon
+  module Download
+    extend ActiveSupport::Concern
+
+    def down_url(uri)
+      connection = ::Faraday.new 
+      response = connection.get(uri)
+      generate_down_cache_directory
+      path = File.join down_cache_path, generate_down_id
+      
+      if response.status != 200
+        raise Balloon::DownloadError, I18n.translate(:"errors.messages.response_error")
+      end
+      
+      if content_type = MIME::Types[response.headers["content-type"]][0]
+        mime_type = content_type.content_type
+        if self.respond_to?(:uploader_mimetype_white)
+           if !uploader_mimetype_white.include?(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?(mime_type)          
+             raise Balloon::DownloadError, I18n.translate(:"errors.messages.down_mime_error")
+           end
+        end
+      end
+
+      File.open(path, "wb") do |f|
+        f.write(response.body)
+      end
+      
+      return path
+    rescue Faraday::Error::ConnectionFailed => e
+      raise Balloon::DownloadError, I18n.translate(:"errors.messages.connection_failed")
+    rescue Faraday::Error::TimeoutError => e
+      raise Ballloon::DownloadError, I18n.translate(:"errors.messages.timeout_error")
+    end
+
+    private
+
+    def generate_down_id
+      now = Time.now
+      "#{now.to_i}#{now.usec.to_s[0, 5]}".to_i.to_s(16)
+    end
+  end
+end
+

data/lib/balloon/error.rb

@@ -0,0 +1,5 @@
+module Balloon
+  class UploadError < StandardError; end
+  class DownloadError < UploadError; end
+  class ProcessError < UploadError; end
+end

data/lib/balloon/file_extension.rb

@@ -0,0 +1,187 @@
+require 'mime/types'
+require 'pathname'
+
+module Balloon
+  # This class is file Extension for ruby class
+  #
+  # @param[File, UploadFile, Hash, String, StringIO] file
+  #
+  # @example
+  #
+  # file = FileExtension.new(file)
+  # file.path 
+  # file.filename 
+  # file.basename 
+  # file.mime_type
+  # file.extension
+  # file.read
+  #
+
+  class FileExtension
+    SANITIZE_REGEX = /[^a-zA-Z0-9\.]|[\^]/
+
+    FILENAME_REGEX = [ /\A(.+)\.(tar\.([glxb]?z|bz2))\z/, /\A(.+)\.([^\.]+)\z/ ]
+
+    IMAGE_REGEX =  [
+      ["GIF8", "image/gif"],
+      ["\x89PNG", "image/png"],
+      ["\xff\xd8\xff\xe0\x00\x10JFIF", "image/jpeg"],
+      ["\xff\xd8\xff\xe1(.*){2}Exif", "image/jpeg"]
+    ]
+
+    IMAGE_EXT_LIST = { 
+      "image/gif" => "gif",
+      "image/jpeg" => "jpg",
+      "image/png" => "png" 
+    }
+
+    def initialize(file, mime_type = nil)
+      if file.is_a?(Hash)
+        @file = file["tempfile"] || file[:tempfile]
+        @original_filename = file["filename"] || file[:filename]
+        @mime_type = file["content_type"] || file[:content_type]
+      else
+        @file = file
+        @original_filename = nil
+        @mime_type = mime_type
+      end
+    end
+
+    # Get real path with uploaded file
+    #
+    # @return [String] file path
+    def path
+      return "" if @file.blank?
+      if @file.is_a?(String) || @file.is_a?(Pathname)
+        File.expand_path(@file)
+      elsif @file.respond_to?(:path)
+        File.expand_path(@file.path)
+      else
+        ""
+      end
+    end
+
+    # Get original filename with uploaded file
+    #
+    # @return [String] file original filename 
+    def original_filename
+      return @original_filename if @original_filename
+      if @file && @file.respond_to?(:original_filename)
+        @file.original_filename
+      elsif !path.blank?
+        File.basename(path)
+      else
+        ""
+      end
+    end
+
+    # Get filename with uploaded file
+    #
+    # @return [string] the real filename
+    def filename
+      return "" if original_filename.blank?
+      sanitize(original_filename) 
+    end
+
+    def basename
+      return "" if filename.blank?
+      split_extension(filename)[0] 
+    end
+
+    def extension
+      ext_name = split_extension(filename)[1] if !filename.blank?
+      return ext_name if !ext_name.blank?
+      return IMAGE_EXT_LIST[mime_type]
+    end
+
+    def mime_type
+      return get_mime_type(MIME::Types[@mime_type]) if @mime_type
+      ext_name = split_extension(filename)[1] if !filename.blank?
+      return get_mime_type(MIME::Types.type_for(ext_name)) if !ext_name.blank? 
+      if type = read_mime_type then return type end
+      if type = command_mime_type then return type end
+    end
+
+    def size
+      return 0 if @file.blank?
+      if @file.is_a?(String)
+        exists? ? File.size(path) : 0
+      elsif @file.respond_to?(:size)
+        @file.size
+      else
+        0
+      end
+    end
+
+    def empty?
+      @file.nil? || self.size.nil? || ( self.size.zero? && !self.exists? )
+    end
+
+    def exists?
+      return File.exists?(self.path) if !path.empty?
+      return false
+    end
+
+    def read(count = nil)
+      return "" if empty?
+      if exists? && @file.is_a?(String)
+        File.open(@file, "rb") {|file| file.read(count) }
+      elsif @file.respond_to?(:read)
+        @file.read(count)
+      else
+        ""
+      end
+    end
+
+
+    # @todo What Change basename add extension
+    def save_to(new_path, permissions = nil, directory_permission = nil)
+      new_path = File.expand_path new_path
+      new_path = File.join new_path, basename + "." + extension 
+
+      if exists?
+        FileUtils.cp(path, new_path) unless new_path == path
+      else
+        File.open(new_path, "wb"){ |f| f.write(read) }
+      end
+      File.chmod(permissions, new_path) if permissions
+      self.class.new(new_path)
+    end
+
+    private
+
+    def sanitize(name)
+      name = name.gsub("\\", "/")
+      name = name.gsub(SANITIZE_REGEX, "_") 
+      name = "_#{name}" if name =~ /\A\.+\z/
+      name = "unnamed" if name.size == 0
+      #name = name.downcase
+      return name.mb_chars.to_s
+    end
+
+    def split_extension(filename)
+      FILENAME_REGEX.each do |regexp|
+        return $1, $2 if filename =~ regexp
+      end
+      return filename, ""
+    end
+
+    def get_mime_type(mime_type)
+      mime_type.first.content_type if !mime_type.empty?
+    end
+
+    def read_mime_type
+      content = read(10)
+      return if content.blank?
+      IMAGE_REGEX.each do |regexp|
+        return regexp[1] if content =~ %r"^#{regexp[0].force_encoding("binary")}"
+      end
+      return nil
+    end
+
+    def command_mime_type
+      content = `file #{path} --mime-type`.gsub("\n", '')
+      content.split(':')[1].strip if content
+    end
+  end   
+end

data/lib/balloon/http/client.rb

@@ -0,0 +1,91 @@
+require 'faraday'
+
+module Balloon
+  module Http
+    class Client
+
+      attr_reader :url
+      
+      attr_reader :login, :pass
+      
+      attr_reader :klass, :token
+
+      attr_accessor :headers
+
+      attr_accessor :options
+
+      attr_accessor :connection
+
+      attr_accessor :conn_build
+
+      def initialize(uri = nil, options = nil, &block)
+        @url = uri
+        yield self if block_given?
+      end
+
+      def builder(&block)
+        @conn_build = block
+      end
+
+      def url=(uri)
+        @conn = nil
+        @url = uri
+      end
+
+      def basic_auth(login, pass)
+        @login = login
+        @pass = pass
+      end
+
+      def token_auth(klass, token)
+        @klass = klass
+        @token = token
+      end
+
+      def connection
+        @connection ||= begin
+                          conn = Faraday.new(url: url)
+                          conn.basic_auth(login, pass) if login
+                          conn.build do |b|
+                            conn_build.call(b)
+                          end if conn_build
+                          conn
+                        end
+      end
+
+      def request(verb, uri, query={}, size = nil)
+        headers['Authorization'] = klass.instance_eval(token.call(verb.to_s.upcase, uri, size, headers['Date'])) if token
+        verb == :get ? query_get = query : query_post = query
+        uri = connection.build_url(uri, query_get)
+        response = connection.run_request(verb, uri, query_post, headers) do |request|
+          yield request if block_given?
+        end
+        response = Response.new(response)
+        case response.status
+        when 301, 302, 303, 307
+          request(verb, response.headers['location'], query)
+        when 200..299, 300..399
+          response
+        end
+      end
+
+      def get(uri, query = {}, &block) 
+        request(:get, uri, query, 0, &block)
+      end
+
+      def post(uri, query = {}, size = nil, &block)
+        size = size || 0
+        request(:post, uri, query, size,&block)
+      end
+
+      def put(uri, query  = {}, size = nil, &block)
+        size = size || 0
+        request(:put, uri, query, size, &block)
+      end
+
+      def delete(uri, &block)
+        request(:delete, uri, nil, 0, &block)
+      end
+    end
+  end
+end

data/lib/balloon/http/response.rb

@@ -0,0 +1,71 @@
+module Balloon
+  module Http
+    class Response
+      attr_reader :response
+
+      CONTENT_TYPE = {
+        'application/json' => :json,
+        'application/x-www-form-urlencoded' => :html,
+        'text/html' => :html,
+        'text/javascript' => :json
+      }
+
+      PARSERS = {
+        :json => lambda{ |body| MultiJson.respond_to?(:adapter) ? MultiJson.load(body) : MultiJson.decode(body) rescue body},
+        :html => lambda{ |body| Nokogiri::HTML(body)}
+      }
+
+      def initialize(response)
+        @response = response
+      end
+
+      def headers
+        response.headers
+      end
+
+      def body
+        decode(response.body)
+      end
+
+      def decode(body)
+        return '' if !body 
+        return body if json?
+        charset = body.match(/charset\s*=[\s|\W]*([\w-]+)/)
+        if charset[1].downcase != "utf-8"
+          begin
+            body.encode! "utf-8", charset[1], {:invalid => :replace} 
+          rescue
+            body
+          end
+        else
+          body
+        end
+      end
+
+      def status
+        response.status
+      end
+
+      # Attempts to determine the content type of the response.
+      def content_type
+        ((response.headers.values_at('content-type', 'Content-Type').compact.first || '').split(';').first || '').strip
+      end
+
+      def json?
+        CONTENT_TYPE[content_type] == :json || !response.body.match(/\<html/)
+      end
+
+      def parser
+        type = CONTENT_TYPE[content_type]
+        type = :json if type == :html && !response.body.match(/\<html/) 
+        return type
+      end
+
+      def parsed
+        return nil unless CONTENT_TYPE.key?(content_type)
+        return nil unless PARSERS.key?(parser)
+        @parsed ||= PARSERS[parser].call(body)
+      end
+    end
+  end
+end

data/lib/balloon/load.rb

@@ -0,0 +1,33 @@
+if defined?(Rails)
+  module Balloon
+    class Railtie < Rails::Railtie
+      initializer "balloon set path" do
+        Balloon.root = Rails.root.to_s
+      end
+
+      initializer "Baloon.configure_rails_initializeation" do
+        config_file = Rails.root.join('config/balloon.yml')
+        if config_file.file?
+          config = YAML.load(ERB.new(config_file.read).result)
+          Balloon.configure_load(config, Rails.env)
+        end
+      end
+    end
+  end
+elsif defined?(Sinatra)
+  if defined?(Padrino) && defined?(PADRINO_ROOT)
+    root = PADRINO_ROOT
+    env = Padrino.env
+  else
+    root = Sinatra::Application.root
+    env = Sinatra::Application.environment
+  end
+  Balloon.root = root
+  config_file = File.join(root, 'config/balloon.yml')
+  if File.exist?(config_file)
+    config = YAML.load(ERB.new(File.read(config_file)).result)
+    Balloon.configure_load(config, env)
+  end
+end
+
+I18n.load_path << File.join(File.dirname(__FILE__), "locale", 'en.yml')

data/lib/balloon/locale/en.yml

@@ -0,0 +1,7 @@
+en:
+  errors:
+    messages:
+      response_error: "Http download errors"
+      connection_failed: "Http connection failed"
+      timeout_error: "Http connection time out"
+      down_mime_error: "Download file content type error"