carrierwave-yandexfotki 0.0.1

data/.gitignore

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

data/Gemfile

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

data/README.md

@@ -0,0 +1,106 @@
+YandexFotki storage for CarrierWave gem
+=======================================
+
+This gem provides a simple way to upload image files from Rails application to [fotki.yandex.ru](http://fotki.yandex.ru) service.
+
+Getting Started
+---------------
+
+In Rails, add it to your Gemfile:
+
+    gem 'carrierwave-yandexfotki'
+
+Quick Start
+-----------
+
+### Creating uploader
+
+Start off by creating an uploader:
+
+    app/uploaders/image_uploader.rb
+
+It should look something like this:
+
+    class ImageUploader < CarrierWave::Uploader::Base
+
+      storage CarrierWave::Storage::YandexFotki
+
+      yandex_login    'login'
+      yandex_password 'password'
+
+      ##
+      #  Uncomment this if you want use 'net/http' library instead 'curb'.
+      #  Also you need install 'multipart-post' gem for use this option.
+      #
+      #yandex_net_http true
+
+      ##
+      # This required for removing old image from fotki.yandex.ru
+      # on updating image attached to model
+      #
+      before :cache, :remove_old_file_before_cache
+
+      def remove_old_file_before_cache(new_file)
+        remove! unless blank?
+      end
+    end
+
+### Mount uploader
+
+Add a string column to the model you want to mount the uploader on:
+
+    add_column :products, :image, :string
+
+Open your model file and mount the uploader:
+
+    class Product
+      mount_before_save_uploader :image, ImageUploader
+    end
+
+**NOTE!** You should use **`mount_before_save_uploader`** instead default `mount_uploader` method for YandexFotki storage.
+
+### Usage
+
+Now you can assign files to the attribute, they will automatically be uploaded when the record is saved.
+
+    product = Product.new
+    product.image = params[:file]
+    product.save!
+    product.image.url # => 'http://img-fotki.yandex.ru/get/path/to/file_orig'
+
+You can get different versions (sizes) of the same image from fotki.yandex.ru (**without need to resize images on your server**):
+
+    product.image.url       # original size image url
+    product.image.url(:xl)  # image fitted to 800x800 px square
+    product.image.url(100)  # image fitted to 100x100 px square
+
+All available sizes:
+
+     Size          |  Side of the bounding square, px
+    ---------------+----------------------------------
+     :orig or nil  |  Original size
+     :xl   or 800  |  800
+     :l    or 500  |  500
+     :m    or 300  |  300
+     :s    or 150  |  150
+     :xs   or 100  |  100
+     :xxs  or 75   |  75 
+     :xxxs or 50   |  50 
+    
+
+You can find this info on this page: [http://api.yandex.ru/fotki/doc/appendices/photo-storage.xml][photo-storage]
+
+[photo-storage]: http://api.yandex.ru/fotki/doc/appendices/photo-storage.xml
+
+Limitations
+-----------
+
+- Only ActiveRecord ORM supported now.
+- Only JPEG, GIF, PNG and BMP images available
+- Limited set of image sizes available
+
+Resources
+---------
+
+- [CarrierWave gem](https://github.com/jnicklas/carrierwave)
+- [YandexFotki API documentation](http://api.yandex.ru/fotki/doc) on russian

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/carrierwave-yandexfotki.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "yandexfotki/version"
+
+Gem::Specification.new do |s|
+  s.name        = "carrierwave-yandexfotki"
+  s.version     = CarrierWave::YandexFotki::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Nickolay Abdrafikov"]
+  s.email       = ["nicck.olay@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{YandexFotki storage for CarrierWave gem}
+  s.description = %q{This gem provides a simple way to upload files from Rails application to fotki.yandex.ru service.}
+
+  s.rubyforge_project = "carrierwave-yandexfotki"
+
+  s.add_dependency('carrierwave', '>= 0.5.2')
+  s.add_dependency('nokogiri')
+  s.add_dependency('curb')
+  # s.add_dependency('multipart-post') # for net_http adapter
+
+  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"]
+end

data/lib/carrierwave-yandexfotki.rb

@@ -0,0 +1,13 @@
+require "yandexfotki/file_url"
+require "yandexfotki/activerecord"
+require "yandexfotki/connection"
+
+require "carrierwave/storage/yandexfotki"
+
+ActiveRecord::Base.extend YandexFotki::ActiveRecord
+
+CarrierWave::Uploader::Base.send :include, YandexFotki::FileUrl
+
+CarrierWave::Uploader::Base.add_config :yandex_login
+CarrierWave::Uploader::Base.add_config :yandex_password
+CarrierWave::Uploader::Base.add_config :yandex_net_http

data/lib/carrierwave/storage/yandexfotki.rb

@@ -0,0 +1,114 @@
+module CarrierWave
+  module Storage
+
+    class YandexFotki < Abstract
+      class File
+        def initialize(uploader, storage, identifier = nil)
+          @uploader   = uploader
+          @storage    = storage
+          @identifier = identifier
+        end
+
+        ##
+        # Remove the file from YandexFotki
+        #
+        def delete
+          if @identifier && @identifier['image_id'].present?
+            connection.delete_foto(@identifier['image_id'])
+          end
+        end
+
+        ##
+        # Returns the url on YandexFotki service
+        #
+        # === Returns
+        #
+        # [String] file's url
+        #
+        def url(style = nil)
+          if style
+            url_resized(style)
+          else
+            url_original
+          end
+        end
+
+        def store(file)
+          @identifier = connection.post_foto(file)
+        end
+
+      private
+      
+        def url_resized(size)
+          if i = %w[800 500 300 150 100 75 50 ORIG ORIGINAL XL L M S XS XXS XXXS].index(size.to_s.upcase)
+            suffix = %w[XL L M S XS XXS XXXS orig orig XL L M S XS XXS XXXS][i]
+          else
+            return nil
+          end
+
+          url_original.gsub(/_[^_]+$/, "_#{suffix}")
+        end
+
+        def url_original
+          @identifier['image_url']
+        end
+
+        def connection
+          @storage.connection
+        end
+      end
+
+      ##
+      # Store the file on YandexFotki
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the file to store
+      #
+      # === Returns
+      #
+      # [YandexFotki::File] the stored file
+      #
+      def store!(file)
+        return if @image_identifier
+
+        f = CarrierWave::Storage::YandexFotki::File.new(uploader, self, @identifier)
+        @image_identifier = f.store(file)
+        f
+      end
+
+      # YAML serialized hash with image info: image_url and image_id
+      #
+      # @return [String]
+      #
+      def identifier
+        @image_identifier.to_yaml if @image_identifier.present?
+      end
+
+      # Do something to retrieve the file
+      #
+      # @param [String] identifier uniquely identifies the file
+      #
+      # [identifier (String)] uniquely identifies the file
+      #
+      # === Returns
+      #
+      # [YandexFotki::File] the stored file
+      #
+      def retrieve!(identifier)
+        identifier = YAML.load(identifier)
+        CarrierWave::Storage::YandexFotki::File.new(uploader, self, identifier)
+      end
+
+      def connection
+        @connection ||= ::YandexFotki::Connection.new(
+          :login    => uploader.yandex_login,
+          :password => uploader.yandex_password,
+          :net_http => uploader.yandex_net_http
+        )
+      end
+
+    end # YandexFotki
+
+  end
+end

data/lib/yandexfotki/activerecord.rb

@@ -0,0 +1,9 @@
+module YandexFotki
+  module ActiveRecord
+    # Same as mount_uploader method but with before_save :store_image! callback
+    def mount_before_save_uploader(*args)
+      before_save "store_#{args.first.to_s}!"
+      mount_uploader(*args)
+    end
+  end
+end

data/lib/yandexfotki/connection.rb

@@ -0,0 +1,107 @@
+require "yandexfotki/encryptor"
+
+module YandexFotki
+
+  class Connection
+    API_HOSTNAME = 'api-fotki.yandex.ru'
+
+    attr_reader :http
+
+    def initialize(credentials)
+      @login    = credentials[:login]
+      @password = credentials[:password]
+
+      if credentials[:net_http]
+        require "yandexfotki/http_adapter/net_http"
+        @http = YandexFotki::HttpAdapter::NetHttp.new
+      else
+        require "yandexfotki/http_adapter/curb"
+        @http = YandexFotki::HttpAdapter::Curb.new
+      end
+    end
+
+    def post_foto(file)
+      image_id  = api_post_foto(file)
+      image_url = api_get_foto_url(image_id)
+
+      return {'image_url' => image_url, 'image_id' => image_id}
+    end
+
+    def delete_foto(image_id)
+      resource_url = api_image_url(image_id)
+
+      http.delete(resource_url, authorization_header)
+    end
+
+    private
+
+    def authorization_header
+      { "Authorization" => %(FimpToken realm="fotki.yandex.ru", token="#{get_token}") }
+    end
+
+    def api_post_foto(file)
+      resource_url = "http://#{API_HOSTNAME}/post/"
+
+      response = http.post_multipart(resource_url, file, authorization_header)
+      image_id = response.split('=').last
+    end
+
+    def api_get_foto_info(image_id)
+      resource_url = api_image_url(image_id)
+
+      http.get(resource_url, authorization_header)
+    end
+
+    def api_set_foto_info(image_id, info_xml)
+      resource_url = api_image_url(image_id)
+
+      http.put(url, info_xml, authorization_header.merge("Content-Type" => 'application/atom+xml; type=entry'))
+    end
+
+    def get_token
+      @token ||= Rails.cache.fetch "YandexFotki:token:#{@login}" do
+        url = "http://auth.mobile.yandex.ru/yamrsa/key/"
+
+        key_xml = http.get(url)
+
+        xml = Nokogiri::XML(key_xml)
+
+        key        = xml.xpath('/response/key').first.content
+        request_id = xml.xpath('/response/request_id').first.content
+
+        text = %(<credentials login="#{@login}" password="#{@password}"/>)
+        credentials = Encryptor.encrypt(key, text)
+
+        url = 'http://auth.mobile.yandex.ru/yamrsa/token/'
+        form_data = {'request_id' => request_id, 'credentials' => credentials}
+        token_xml_str = http.post_form(url, form_data)
+
+        token_xml = Nokogiri::XML(token_xml_str)
+        token_xml.xpath('/response/token').first.content
+      end
+    end
+
+    def api_image_url(image_id)
+      "http://#{API_HOSTNAME}/api/users/#{@login}/photo/#{image_id}/" if image_id.present?
+    end
+
+    def api_get_foto_url(image_id)
+      img_url = nil
+
+      attempts = 3
+      while img_url.nil? && attempts > 0 do
+        attempts -= 1
+
+        info_xml    = api_get_foto_info(image_id)
+        content_tag = Nokogiri::XML(info_xml).css('entry>content')
+
+        img_url = content_tag.attribute('src').value rescue nil
+      end
+
+      raise "can't fetch src for foto ##{image_id}" if img_url.nil?
+
+      img_url
+    end
+  end
+
+end

data/lib/yandexfotki/encryptor.rb

@@ -0,0 +1,63 @@
+module YandexFotki
+
+  class Encryptor
+    class << self
+      def encrypt(key, data)
+        public_key, text = key, data 
+
+        nstr, estr = public_key.split("#")
+        data_arr = []
+        text.each_byte {|b| data_arr << b}
+
+        n, e, step_size = nstr.hex, estr.hex, nstr.size/2-1
+
+        prev_crypted = Array.new(step_size, 0)
+
+        hex_out = ""
+
+        ((data_arr.size-1)/step_size+1).times do |i|
+          tmp = data_arr[i*step_size...(i+1)*step_size]
+
+          new_tmp = []
+          tmp.each_with_index {|t,ii| new_tmp << (t^prev_crypted[ii])}
+          tmp = new_tmp.reverse
+
+          plain = 0
+          tmp.each_with_index {|t,ii| plain += t*(256**ii%n)}
+          hex_result = "%x" % power_modulo(plain, e, n) # plain ** e % n
+          hex_result = hex_result.rjust(nstr.size, '0')
+
+          (0...[hex_result.size, prev_crypted.size*2].min).step(2) do |x|
+            prev_crypted[x/2] = hex_result[x...(x+2)].hex
+          end
+
+          hex_out += (tmp.size < 16 ? "0" : "") + ("%x" % tmp.size) + "00"
+          ks = nstr.size/2
+
+          hex_out += (ks < 16 ? "0" : "") + ("%x" % ks) + "00"
+          hex_out += hex_result
+        end
+
+        hs = []
+        hex_out.scan(/../).each{|x| hs << x.hex.chr}
+        hs = hs.join
+        Base64.encode64(hs).gsub("\n","")
+      end
+
+      private
+
+      # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/71964
+      def power_modulo(b, p, m)
+        if p == 1
+          b % m
+        elsif (p & 0x1) == 0 # p.even?
+          t = power_modulo(b, p >> 1, m)
+          (t * t) % m
+        else
+          (b * power_modulo(b, p-1, m)) % m
+        end
+      end
+    end
+  end
+
+end

data/lib/yandexfotki/file_url.rb

@@ -0,0 +1,9 @@
+module YandexFotki
+
+  module FileUrl
+    def url(*args)
+      file.url(*args) || super
+    end
+  end
+
+end

data/lib/yandexfotki/http_adapter/curb.rb

@@ -0,0 +1,51 @@
+require "curb"
+
+module YandexFotki
+  module HttpAdapter
+
+    class Curb
+      def get(url, headers = {})
+        curl = Curl::Easy.new(url)
+        curl.headers["Authorization"] = headers['Authorization'] if headers['Authorization']
+        curl.http_get
+        curl.body_str
+      end
+
+      def delete(url, headers)
+        curl = Curl::Easy.new(url)
+        curl.headers["Authorization"] = headers['Authorization']
+        curl.http_delete
+        curl.body_str
+      end
+
+      def post_form(url, form_data)
+        curl = Curl::Easy.new(url)
+        curl.http_post(
+          Curl::PostField.content('request_id', form_data['request_id']),
+          Curl::PostField.content('credentials', form_data['credentials'])
+        )
+        curl.body_str
+      end
+
+      def post_multipart(url, file, headers)
+        curl = Curl::Easy.new(url)
+        curl.headers["Authorization"] = headers['Authorization']
+        curl.multipart_form_post = true
+        curl.http_post(
+          Curl::PostField.file('image', file.path, file.filename),
+          Curl::PostField.content('yaru', '0')
+        )
+        curl.body_str
+      end
+
+      def put(url, data, headers)
+        curl = Curl::Easy.new(url)
+        curl.headers["Authorization"] = headers['Authorization']
+        curl.headers["Content-Type"] = headers['Content-Type']
+        curl.http_put(data)
+        curl.body_str
+      end
+    end
+
+  end
+end

data/lib/yandexfotki/http_adapter/net_http.rb

@@ -0,0 +1,68 @@
+require "net/http"
+require "net/http/post/multipart" # multipart-post gem
+
+module YandexFotki
+  module HttpAdapter
+
+    class NetHttp
+      def get(url, headers = {})
+        url = URI.parse(url)
+
+        http = Net::HTTP.new(url.host)
+        request = Net::HTTP::Get.new(url.path)
+        request["Authorization"] = headers['Authorization'] if headers['Authorization']
+
+        response = http.request(request)
+        response.body
+      end
+
+      def delete(url, headers)
+        url = URI.parse(url)
+
+        http = Net::HTTP.new(url.host)
+        request = Net::HTTP::Delete.new(url.path)
+        request["Authorization"] = headers['Authorization']
+
+        response = http.request(request)
+        response.body
+      end
+
+      def post_form(url, form_data)
+        url = URI.parse(url)
+
+        response = Net::HTTP.post_form(url, form_data)
+        response.body
+      end
+
+      def post_multipart(url, file, headers)
+        url = URI.parse(url)
+
+        file_io = ::File.open(file.path)
+        form_data = {
+          "image" => UploadIO.new(file_io, file.content_type, file.filename),
+          "yaru"  => 0
+        }
+
+        http = Net::HTTP.new(url.host)
+        request = Net::HTTP::Post::Multipart.new(url.path, form_data)
+        request["Authorization"] = headers['Authorization']
+
+        response = http.request(request, nil)
+        response.body
+      end
+
+      def put(url, data, headers)
+        url = URI.parse(url)
+
+        http = Net::HTTP.new(url.host)
+        request  = Net::HTTP::Put.new(url.path)
+        request["Authorization"] = headers['Authorization']
+        request['Content-Type'] = headers['Content-Type']
+
+        response = http.request(request, data)
+        response.body
+      end
+    end
+
+  end
+end

data/lib/yandexfotki/version.rb

@@ -0,0 +1,5 @@
+module CarrierWave
+  module YandexFotki
+    VERSION = "0.0.1"
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: carrierwave-yandexfotki
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nickolay Abdrafikov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-23 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: carrierwave
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: curb
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: This gem provides a simple way to upload files from Rails application to fotki.yandex.ru service.
+email: 
+- nicck.olay@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- carrierwave-yandexfotki.gemspec
+- lib/carrierwave-yandexfotki.rb
+- lib/carrierwave/storage/yandexfotki.rb
+- lib/yandexfotki/activerecord.rb
+- lib/yandexfotki/connection.rb
+- lib/yandexfotki/encryptor.rb
+- lib/yandexfotki/file_url.rb
+- lib/yandexfotki/http_adapter/curb.rb
+- lib/yandexfotki/http_adapter/net_http.rb
+- lib/yandexfotki/version.rb
+has_rdoc: true
+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: carrierwave-yandexfotki
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: YandexFotki storage for CarrierWave gem
+test_files: []
+