imagevenue 0.0.1

data/image_venue.rb

@@ -0,0 +1,51 @@
+require 'cgi' unless defined?(CGI::Cookie)
+require 'net/http' unless defined?(Net::HTTP)
+require 'image_venue/net_http_get_extensions' unless defined?(NetHttpGetExtensions)
+require 'image_venue/net_http_post_extensions' unless defined?(NetHttpPostExtensions)
+require 'open-uri' unless defined?(OpenURI)
+require 'uri' unless defined?(URI)
+require 'rubygems' unless defined?(Gem)
+require 'hpricot' unless defined?(Hpricot)
+
+module ImageVenue
+  def self.base_url
+    @base_url ||= 'http://users.imagevenue.com'
+  end
+
+  def self.base_uri
+    @base_uri ||= URI.parse(self.base_url)
+  end
+
+  def self.version
+    @version ||= [0, 0, 1]
+  end
+
+  def self.debug
+    @debug
+  end
+
+  def self.debug=(debug)
+    @debug = debug
+  end
+
+  def self.authenticate(username=nil, password=nil, cookie=nil)
+    @authenticate ||= ImageVenue::Authenticate.new(username, password, cookie)
+  end
+
+  def self.directory
+    @directory ||= ImageVenue::Directory.new
+  end
+
+  def self.upload
+    @upload ||= ImageVenue::Upload.new
+  end
+end
+
+require 'image_venue/authenticate'
+require 'image_venue/directory'
+require 'image_venue/file'
+require 'image_venue/upload'
+require 'image_venue/upload_file'
+
+if $0 == __FILE__
+end

data/image_venue/authenticate.rb

@@ -0,0 +1,125 @@
+module ImageVenue
+  class Authenticate
+    class << self
+      def login_uri
+        @login_uri ||= URI.parse(ImageVenue.base_url + '/process_logon.php')
+      end
+
+      def login_username_key
+        @login_username_key ||= 'user'
+      end
+
+      def login_password_key
+        @login_password_key ||= 'password'
+      end
+
+      def login_action_key
+        @login_action_key ||= 'action'
+      end
+
+      def logout_uri
+        @logout_uri ||= URI.parse(ImageVenue.base_url + '/logout.php')
+      end
+
+      def cookie_user_key
+        @cookie_user_key ||= 'user'
+      end
+
+      def cookie_root_key
+        @cookie_root_key ||= 'root'
+      end
+
+      def cookie_timestamp_key
+        @cookie_timestamp_key ||= 'tsctr'
+      end
+    end
+
+    attr_accessor :action
+    attr_accessor :username
+    attr_accessor :password
+    attr_accessor :cookie
+    attr_accessor :debug
+
+    def initialize(username, password, cookie=nil)
+      self.action = '1'
+      self.username = username
+      self.password = password
+      self.cookie = cookie
+      return nil
+    end
+
+    def debug?
+      (ImageVenue.debug or self.debug) ? true : false
+    end
+
+    def puts_debug(*args)
+      if self.debug?
+        puts(*args)
+        return true
+      else
+        return false
+      end
+    end
+
+    def login
+      puts_debug "Trying to login ..."
+      response = Net::HTTP.post_form(self.class.login_uri, self.login_params)
+      unless response.header['Set-Cookie'].blank?
+        self.cookie = {}
+        self.cookie[self.class.cookie_user_key] = $1 if response.header['Set-Cookie'] =~ /#{Regexp.escape(self.class.cookie_user_key)}=(.+?)[,;]/
+        self.cookie[self.class.cookie_root_key] = $1 if response.header['Set-Cookie'] =~ /#{Regexp.escape(self.class.cookie_root_key)}=(\d+)/
+        response_timestamp = Net::HTTP.get_response(ImageVenue.base_uri)
+        unless response_timestamp.header['Set-Cookie'].blank?
+          self.cookie[self.class.cookie_timestamp_key] = $1 if response_timestamp.header['Set-Cookie'] =~ /#{Regexp.escape(self.class.cookie_timestamp_key)}=(.+?)[,;]/
+          puts_debug "Login successfull!"
+          return true
+        else
+          puts_debug "Login failed!"
+          return false
+        end
+      else
+        self.cookie = nil
+        return false
+      end
+    end
+
+    def login_params
+      {
+        self.class.login_action_key => self.action,
+        self.class.login_username_key => self.username,
+        self.class.login_password_key => self.password
+      }
+    end
+
+    def logged_in?
+      unless self.cookie.nil?
+        return true
+      else
+        return false
+      end
+    end
+
+    def logout
+      puts_debug "Trying to logout ..."
+      response = Net::HTTP.get_response(self.class.logout_uri)
+      if response.is_a?(Net::HTTPSuccess) or response.is_a?(Net::HTTPFound)
+        self.cookie = nil
+        puts_debug "Logout successfull! Resetting cookie."
+        return true
+      else
+        self.cookie = nil
+        puts_debug "Logout failed! But resetting cookie anyway."
+        return false
+      end
+    end
+
+    def cookie_as_string
+      unless self.cookie.nil?
+        cookie_str = self.cookie.map {|key, value| [key, value].join('=')}.join('; ')
+        return cookie_str
+      else
+        return nil
+      end
+    end
+  end
+end

data/image_venue/directory.rb

@@ -0,0 +1,266 @@
+module ImageVenue
+  class Directory
+    class << self
+      def list_uri
+        @list_uri ||= URI.parse(ImageVenue.base_url + '/view_dir.php')
+      end
+
+      def files_uri
+        @files_uri ||= URI.parse(ImageVenue.base_url + '/process_get_dir_codes.php')
+      end
+
+      def files_format_key
+        @files_format_key ||= 'poster'
+      end
+
+      def files_format_forum
+        @files_format_forum ||= 'forum'
+      end
+
+      def files_format_website
+        @files_format_website ||= 'webpage'
+      end
+
+      def files_directory_key
+        @files_directory_key ||= 'dir'
+      end
+
+      def select_uri
+        @select_uri ||= URI.parse(ImageVenue.base_url + '/process_change_dir.php')
+      end
+
+      def select_directory_key
+        @select_directory_key ||= 'dir'
+      end
+
+      def create_uri
+        @create_uri ||= URI.parse(ImageVenue.base_url + '/create_dir.php')
+      end
+
+      def create_directory_key
+        @create_directory_key ||= 'new_dir'
+      end
+
+      def delete_uri
+        @delete_uri ||= URI.parse(ImageVenue.base_url + '/process_del_dir.php')
+      end
+
+      def delete_directory_key
+        @delete_directory_key ||= 'delete_dir[]'
+      end
+
+      def cookie_directory_key
+        @cookie_directory_key ||= 'cur_upload_dir'
+      end
+    end
+
+    attr_accessor :directories
+    attr_accessor :directories_files
+    attr_accessor :selected_directory
+    attr_accessor :debug
+
+    alias :selected :selected_directory
+
+    def initialize
+      self.directories = nil
+      self.directories_files = {}
+      self.selected_directory = nil
+      return nil
+    end
+
+    def debug?
+      (ImageVenue.debug or self.debug) ? true : false
+    end
+
+    def puts_debug(*args)
+      if self.debug?
+        puts(*args)
+        return true
+      else
+        return false
+      end
+    end
+
+    def list(reload=false)
+      if self.directories.nil? or reload
+        puts_debug "Trying to fetch directories ..."
+        request = Net::HTTP::Get.new(self.class.list_uri.path)
+        request.header['cookie'] = [ImageVenue.authenticate.cookie_as_string]
+        response = Net::HTTP.start(self.class.list_uri.host, self.class.list_uri.port) do |http|
+          http.request(request)
+        end
+        if response.is_a?(Net::HTTPSuccess)
+          hpricot = Hpricot(response.body)
+          self.directories = hpricot.search('form:first').first.search('input[@type="radio"]').collect {|input| input['value']}
+          puts_debug "Directories successfully fetched!"
+          return self.directories
+        else
+          puts_debug "Directories fetch failed!"
+          return false
+        end
+      else
+        puts_debug "Directories from cache!"
+        return self.directories
+      end
+    end
+
+    def files(directory, reload=false)
+      if self.directories_files[directory].nil? or reload
+        puts_debug "Trying to fetch files from directory: '#{directory}' ..."
+        request = Net::HTTP::Post.new(self.class.files_uri.path)
+        request.form_data = self.files_params(directory)
+        request.header['cookie'] = [ImageVenue.authenticate.cookie_as_string]
+        response = Net::HTTP.start(self.class.files_uri.host, self.class.files_uri.port) do |http|
+          http.request(request)
+        end
+        if response.is_a?(Net::HTTPSuccess)
+          self.directories_files[directory] = ImageVenue::File.parse_forum_codes(response.body, directory)
+          puts_debug "Files successfully fetched!"
+          return self.directories_files[directory]
+        else
+          puts_debug "Files fetch failed!"
+          return false
+        end
+      else
+        puts_debug "Files from cache for directory: '#{directory}'"
+        return self.directories_files[directory]
+      end
+    end
+
+    def files_params(directory)
+      {
+        self.class.files_format_key => self.class.files_format_forum,
+        self.class.files_directory_key => directory
+      }
+    end
+
+    def select(directory, reselect=false)
+      if directory != self.selected_directory or reselect
+        puts_debug "Trying to select directory: '#{directory}'"
+        request = Net::HTTP::Post.new(self.class.select_uri.path)
+        request.form_data = self.select_params(directory)
+        request.header['cookie'] = [ImageVenue.authenticate.cookie_as_string]
+        response = Net::HTTP.start(self.class.select_uri.host, self.class.select_uri.port) do |http|
+          http.request(request)
+        end
+        if response.is_a?(Net::HTTPFound) and not response.header['Set-Cookie'].blank?
+          self.selected_directory = directory
+          ImageVenue.authenticate.cookie[self.class.cookie_directory_key] = directory
+          puts_debug "Directory successfully selected!"
+          return true
+        else
+          puts_debug "Directory select failed!"
+          return false
+        end
+      else
+        puts_debug "Directory already selected."
+        return nil
+      end
+    end
+
+    def select_params(directory)
+      {
+        self.class.select_directory_key => directory
+      }
+    end
+
+    def create(directory, reload=false)
+      unless self.list(reload).include?(directory)
+        puts_debug "Trying to create directory: '#{directory}'"
+        request = Net::HTTP::Post.new(self.class.create_uri.path)
+        request.form_data = self.create_params(directory)
+        request.header['cookie'] = [ImageVenue.authenticate.cookie_as_string]
+        response = Net::HTTP.start(self.class.create_uri.host, self.class.create_uri.port) do |http|
+          http.request(request)
+        end
+        if response.is_a?(Net::HTTPSuccess) and not response.header['Set-Cookie'].blank?
+          self.selected_directory = directory
+          self.directories.insert(0, directory)
+          ImageVenue.authenticate.cookie[self.class.cookie_directory_key] = directory
+          puts_debug "Directory successfully created!"
+          return true
+        else
+          puts_debug "Directory create failed!"
+          return false
+        end
+      else
+        puts_debug "Directory already exists: '#{directory}'"
+        return nil
+      end
+    end
+
+    def create_params(directory)
+      {
+        self.class.create_directory_key => directory
+      }
+    end
+
+    def select_or_create(directory, reload=false, reselect=false)
+      if self.list(reload).include?(directory)
+        return self.select(directory, reselect)
+      else
+        return self.create(directory, false) # reload)
+      end
+    end
+
+    def delete(directory, reload=false)
+      if self.list(reload).include?(directory)
+        puts_debug "Trying to delete directory: '#{directory}'"
+        request = Net::HTTP::Post.new(self.class.delete_uri.path)
+        request.form_data = self.delete_params(directory)
+        request.header['cookie'] = [ImageVenue.authenticate.cookie_as_string]
+        response = Net::HTTP.start(self.class.delete_uri.host, self.class.delete_uri.port) do |http|
+          http.request(request)
+        end
+        if response.is_a?(Net::HTTPSuccess)
+          if directory == self.selected_directory
+            self.selected_directory = nil
+            ImageVenue.authenticate.cookie.delete(self.class.cookie_directory_key)
+          end
+          self.directories.delete(directory)
+          self.directories_files.delete(directory)
+          puts_debug "Directory successfully deleted!"
+          return true
+        else
+          puts_debug "Directory delete failed!"
+          return false
+        end
+      else
+        puts_debug "Directory does not exist: '#{directory}'"
+        return nil
+      end
+    end
+
+    def delete_params(directory)
+      {
+        self.class.delete_directory_key => directory
+      }
+    end
+
+    def delete_file(file, reload=false)
+      directory = file.directory
+      files = self.files(directory, reload)
+      puts_debug "Trying to delete file '#{file.basename}' from directory '#{file.directory}' ..."
+      if file.delete
+        files.delete(file)
+        puts_debug "File successfully deleted!"
+        return true
+      else
+        puts_debug "File delete failed!"
+        return false
+      end
+    end
+
+    def clear(directory=nil)
+      if directory.nil?
+        self.directories = []
+        self.directories_files = {}
+        puts_debug "Directories cache cleared!"
+      else
+        self.directories_files.delete(directory)
+        puts_debug "Directory's `#{directory}` cache cleared!"
+      end
+      return true
+    end
+  end
+end

data/image_venue/file.rb

@@ -0,0 +1,153 @@
+module ImageVenue
+  class File
+    class << self
+      def parse_upload(response_body)
+        hpricot = Hpricot(response_body)
+        textareas = hpricot.search('textarea')
+        image_url = textareas[0].inner_text.strip
+        file = self.new(image_url, ImageVenue.directory.selected)
+        return file
+      end
+
+      def parse_forum_codes(response_body, directory)
+        files = []
+        hpricot = Hpricot(response_body)
+        image_urls = hpricot.search('p:last').last.inner_text.scan(/\[URL=(.+?)\]/i).flatten
+        image_urls.each do |image_url|
+          file = self.new(image_url, directory)
+          files.push(file)
+        end
+        return files
+      end
+
+      def delete_uri
+        @delete_uri ||= URI.parse(ImageVenue.base_url + '/manage_files.php')
+      end
+
+      def delete_file_key
+        @delete_file_key ||= 'delete_files[]'
+      end
+
+      def delete_submit_key
+        @delete_submit_key ||= 'submit'
+      end
+
+      def delete_submit_value
+        @delete_submit_value ||= 'Delete'
+      end
+
+      def cookie_view_directory
+        @cookie_view_directory ||= 'view_dir'
+      end
+    end
+
+    attr_accessor :directory
+    attr_accessor :image_url
+    attr_accessor :debug
+
+    def initialize(image_url, directory=nil)
+      self.directory = directory
+      self.image_url = image_url
+      return nil
+    end
+
+    def debug?
+      (ImageVenue.debug or self.debug) ? true : false
+    end
+
+    def puts_debug(*args)
+      if self.debug?
+        puts(*args)
+        return true
+      else
+        return false
+      end
+    end
+
+    def image_io
+      if @image_io.nil?
+        puts_debug "Trying to fetch image data ..."
+        image_html = open(self.image_url)
+        image_uri = URI.parse(self.image_url)
+        image_uri.path = '/' + Hpricot(image_html).search('img[@id="thepic"]:first').first['src']
+        @image_io = open(image_uri)
+        puts_debug "Image data successfully fetched!"
+      else
+        puts_debug "Image data from cache!"
+      end
+      return @image_io
+    end
+
+    def thumbnail_io
+      if @thumbnail_io.nil?
+        puts_debug "Trying to fetch thumbnail data ..."
+        @thumbnail_io = open(self.thumbnail_url)
+        puts_debug "Thumbnail data successfully fetched!"
+      else
+        puts_debug "Thumbnail data from cache!"
+      end
+      return @thumbnail_io
+    end
+
+    def thumbnail_url
+      if @thumbnail_url.nil? and self.image_url =~ /_(\d+)lo/
+        @thumbnail_url = self.image_url.gsub('img.php?image=', "loc#{$1}/th_")
+      end
+      return @thumbnail_url
+    end
+
+    def thumbnail_for_board_upper
+      @thumbnail_for_board_upper ||= "[URL=#{self.image_url}][IMG]#{self.thumbnail_url}[/IMG][/URL]"
+    end
+
+    def thumbnail_for_board_lower
+      @thumbnail_for_board_lower ||= "[url=#{self.image_url}][img]#{self.thumbnail_url}[/img][/url]"
+    end
+
+    def thumbnail_for_website
+      @thumbnail_for_website ||= "<a href=\"#{self.image_url}\" target=_blank><img src=\"#{self.thumbnail_url}\" border=\"0\"></a>"
+    end
+
+    def basename
+      @basename ||= $1 if self.image_url =~ /image=(.+)$/
+    end
+
+    def clear
+      @image_io = nil
+      @thumbnail_io = nil
+      @thumbnail_url = nil
+      @thumbnail_for_board_upper = nil
+      @thumbnail_for_board_lower = nil
+      @thumbnail_for_website = nil
+      @basename = nil
+      puts_debug "File's `#{self.basename}` cache cleared!"
+      return true
+    end
+
+    def delete
+      puts_debug "Trying to delete file `#{self.basename}` from directory `#{self.directory}` ..."
+      request = Net::HTTP::Post.new(self.class.delete_uri.path)
+      request.form_data = self.delete_params
+      ImageVenue.authenticate.cookie[self.class.cookie_view_directory] = self.directory
+      request.header['cookie'] = [ImageVenue.authenticate.cookie_as_string]
+      response = Net::HTTP.start(self.class.delete_uri.host, self.class.delete_uri.port) do |http|
+        http.request(request)
+      end
+      ImageVenue.authenticate.cookie.delete(self.class.cookie_view_directory)
+      if response.is_a?(Net::HTTPSuccess)
+        puts_debug "File `#{self.basename}` successfully deleted!"
+        return true
+      else
+        puts_debug "File `#{self.basename}` delete failed!"
+        return false
+      end
+    end
+
+    def delete_params
+      {
+        self.class.delete_submit_key => self.class.delete_submit_value,
+        self.class.delete_file_key => self.basename
+      }
+    end
+  end
+end

data/image_venue/net_http_get_extensions.rb

@@ -0,0 +1,20 @@
+module ImageVenue
+  module NetHttpGetExtensions
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+      base.send(:include, InstanceMethods)
+      base.class_eval do
+        attr_accessor :header
+      end
+      return nil
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+    end
+  end
+end
+
+Net::HTTP::Get.send(:include, ImageVenue::NetHttpGetExtensions)

data/image_venue/net_http_post_extensions.rb

@@ -0,0 +1,157 @@
+# Multipart POST file upload for Net::HTTP::Post.
+#
+# By Leonardo Boiko <leoboiko@gmail.com>, public domain.
+# By Michael Nowak <thexsystem@web.de>, public domain.
+#
+# Usage: see documentation for Net::HTTP::Post#set_multipart_data.
+
+require 'fileutils' unless defined?(FileUtils)
+
+module ImageVenue
+  module NetHttpPostExtensions
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+      base.send(:include, InstanceMethods)
+      base.class_eval do
+        attr_accessor :header
+      end
+      return nil
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+      # Similar to Net::HTTP::Post#set_form_data (in Ruby's stardard
+      # library), but set up file upload parameters using the
+      # appropriate HTTP/HTML Forms multipart format.
+      #
+      # *Arguments*
+      #
+      # files_params:: A hash of file upload parameters.  The keys are
+      #                parameter names, and the values are
+      #                Net::HTTP::FileForPost instances.  See that
+      #                class documentation for more info about how
+      #                POST file upload works.
+      #
+      # other_params:: A hash of {key => value} pairs for the regular
+      #                POST parameters, just like in set_form_data.
+      #                Don't mix set_form_data and set_multipart_data;
+      #                they'll overwrite each other's work.
+      #
+      # boundary1, boundary2:: A couple of strings which doesn't occur
+      #                        in your files.  Boundary2 is only
+      #                        needed if you're using the
+      #                        multipart/mixed technique.  The
+      #                        defaults should be OK for most cases.
+      #
+      # *Examples*
+      #
+      # Simplest case (single-parameter single-file), complete:
+      #
+      #   require 'net/http'
+      #   require 'net_http_post_extensions'
+      #
+      #   req = Net::HTTP::Post.new('/scripts/upload.rb')
+      #   req.basic_auth('jack', 'inflamed sense of rejection')
+      #
+      #   file = Net::HTTP::FileForPost.new('/body/yourlife.txt', 'text/plain')
+      #   req.set_multipart_data({:poem => file},
+      #
+      #                          {:author => 'jack',
+      #                            :user_agent => 'soapfactory'})
+      #
+      #   res = Net::HTTP.new(url.host, url.port).start do |http|
+      #     http.request(req)
+      #   end
+      #
+      # Convoluted example:
+      #
+      #   pic1 = Net::HTTP::FileForPost.new('pic1.jpeg', 'image/jpeg')
+      #   pic2 = Net::HTTP::FileForPost.new(pic2_io, 'image/jpeg')
+      #   pic3 = Net::HTTP::FileForPost.new('pic3.png', 'image/png')
+      #   pic1_t = Net::HTTP::FileForPost.new('pic1_thumb.jpeg', 'image/jpeg')
+      #   pic2_t = Net::HTTP::FileForPost.new(pic2_t_io, 'image/jpeg')
+      #   desc = Net::HTTP::FileForPost.new('desc.html', 'text/html',
+      #                                      'index.html') # remote fname
+      #
+      #   req.set_multipart_data({:gallery_description => des,
+      #                           :pictures => [pic1, pic2, pic3],
+      #                           :thumbnails => [pic1_t, pic2_t]},
+      #
+      #                          {:gallery_name => 'mygallery',
+      #                           :encoding => 'utf-8'})
+      #
+      def set_multipart_data(files_params, other_params={}, boundary1='paranguaricutirimirruaru0xdeadbeef', boundary2='paranguaricutirimirruaru0x20132')
+        self.content_type = "multipart/form-data; boundary=\"#{boundary1}\""
+
+        body = StringIO.new('r+b')
+
+        # let's do the easy ones first
+        other_params.each do |key, value|
+          body.write "--#{boundary1}\r\n"
+          body.write "content-disposition: form-data; name=\"#{key}\"\r\n"
+          body.write "\r\n"
+          body.write "#{value}\r\n"
+        end
+
+        # now handle the files...
+        files_params.each do |name, file_or_files|
+          files = [file_or_files].flatten
+
+          if name.to_s =~ /\[\]$/
+            files.each do |file|
+              body.write "\r\n--#{boundary1}\r\n"
+              body.write "content-disposition: form-data; name=\"#{name}\""
+              # single-file multipart is different
+              if file.filename
+                # right in content-dispo line
+                body.write "; filename=\"#{file.filename}\"\r\n"
+              else
+                body.write "\r\n"
+              end
+
+              body.write "Content-Type: #{file.content_type}\r\n"
+              body.write "Content-Transfer-Encoding: binary\r\n"
+              body.write "\r\n"
+              FileUtils.copy_stream(file, body)
+            end
+          else
+            body.write "\r\n--#{boundary1}\r\n"
+            body.write "content-disposition: form-data; name=\"#{name}\""
+            # multiple-file parameter (multipart/mixed)
+            body.write "\r\n"
+            body.write "Content-Type: multipart/mixed;"
+            body.write " boundary=\"#{boundary2}\"\r\n"
+
+            files.each do |file|
+              body.write "\r\n--#{boundary2}\r\n"
+
+              body.write "Content-disposition: attachment"
+              if file.filename
+                body.write "; filename=\"#{file.filename}\"\r\n"
+              else
+                body.write "\r\n"
+              end
+
+              body.write "Content-Type: #{file.mimetype}\r\n"
+              body.write "Content-Transfer-Encoding: binary\r\n"
+              body.write "\r\n"
+              FileUtils.copy_stream(file, body)
+            end
+            body.write "\r\n--#{boundary2}--\r\n"
+          end
+        end
+        body.write "--#{boundary1}--\r\n"
+
+        body.flush
+        self.content_length = body.size
+        self.body_stream = body
+        self.body_stream.rewind
+        return true
+      end
+    end
+  end
+end
+
+Net::HTTP::Post.send(:include, ImageVenue::NetHttpPostExtensions)

data/image_venue/upload.rb

@@ -0,0 +1,137 @@
+module ImageVenue
+  class Upload
+    class << self
+      def upload_uri
+        @upload_uri ||= URI.parse(ImageVenue.base_url + '/upload.php')
+      end
+
+      def upload_action_key
+        @upload_action_key ||= 'action'
+      end
+
+      def upload_user_key
+        @upload_user_key ||= 'user_id'
+      end
+
+      def upload_file_key
+        @upload_file_key ||= 'userfile[]'
+      end
+
+      def upload_directory_key
+        @upload_directory_key ||= 'upload_dir'
+      end
+
+      def upload_content_key
+        @upload_content_key ||= 'imgcontent'
+      end
+
+      def upload_content_safe
+        @upload_content_safe ||= 'safe'
+      end
+      alias :upload_content_family :upload_content_safe
+
+      def upload_content_notsafe
+        @upload_content_notsafe ||= 'notsafe'
+      end
+      alias :upload_content_adult :upload_content_notsafe
+
+      def upload_resize_key
+        @upload_resize_key ||= 'img_resize'
+      end
+
+      def upload_maximum_files
+        @upload_maximum_files ||= 10
+      end
+
+      def upload_maximum_size
+        @upload_maximum_size ||= 3 * 1024 * 1024 # 3 MByte
+      end
+
+      def upload_image_types
+        @upload_image_types ||= ['jpeg', 'jpg']
+      end
+    end
+
+    attr_accessor :files
+    attr_accessor :debug
+
+    def initialize
+      self.files = []
+      return nil
+    end
+
+    def debug?
+      (ImageVenue.debug or self.debug) ? true : false
+    end
+
+    def puts_debug(*args)
+      if self.debug?
+        puts(*args)
+        return true
+      else
+        return false
+      end
+    end
+
+    def add(image_venue_file)
+      if image_venue_file.is_a?(ImageVenue::UploadFile)
+        self.files.push(image_venue_file)
+        return true
+      else
+        return false
+      end
+    end
+
+    def upload
+      files = []
+      self.files.each do |file|
+        puts_debug "Trying to upload file `#{file.filename}` to directory `#{file.directory}` ..."
+        request = Net::HTTP::Post.new(self.class.upload_uri.path)
+        request.set_multipart_data(self.upload_file_params(file), self.upload_form_params(file.directory))
+        request.header['cookie'] = [ImageVenue.authenticate.cookie_as_string]
+        response = Net::HTTP.start(self.class.upload_uri.host, self.class.upload_uri.port) do |http|
+          http.request(request)
+        end
+        if response.is_a?(Net::HTTPSuccess)
+          file = ImageVenue::File.parse_upload(response.body)
+          puts_debug "File successfully uploaded!"
+        else
+          file = false
+          puts_debug "File upload failed!"
+        end
+        files.push(file)
+      end
+      return files
+    end
+    alias :process :upload
+
+    def upload_file_params(file_or_files=nil)
+      {
+        self.class.upload_file_key => file_or_files
+      }
+    end
+
+    def upload_form_params(directory=nil, content_safe=false, resize=nil)
+      unless directory.nil?
+        ImageVenue.directory.select_or_create(directory)
+      end
+      params = {
+        self.class.upload_action_key => '1',
+        self.class.upload_directory_key => ImageVenue.directory.selected,
+        self.class.upload_user_key => ImageVenue.authenticate.cookie[ImageVenue::Authenticate.cookie_user_key],
+        self.class.upload_content_key => (content_safe) ? self.class.upload_content_safe : self.class.upload_content_notsafe,
+        self.class.upload_resize_key => resize || ''
+      }
+      return params
+    end
+
+    def status
+      return nil
+    end
+
+    def reset
+      self.files = []
+      return self
+    end
+  end
+end

data/image_venue/upload_file.rb

@@ -0,0 +1,84 @@
+module ImageVenue
+  class UploadFile
+    class << self
+      def content_types
+        @content_types ||= ['jpeg', 'jpg']
+      end
+
+      def from_local_path(path)
+        file = Kernel::File.open(path, 'rb')
+        content_type = `file --mime --brief #{file.path}`.strip
+        filename = Kernel::File.basename(file.path)
+        data = file.read
+        new = self.new(content_type, filename, data)
+        return new
+      end
+      alias :from_path :from_local_path
+
+      def from_files(files, directory)
+        news = []
+        files.each do |file|
+          new = self.new(file.content_type, file.original_filename, file, directory)
+          news.push(new)
+        end
+        return news
+      end
+
+      def upload_file_test
+        @upload_file_test ||= self.from_local_path(Kernel::File.join(Kernel::File.dirname(__FILE__), 'test.jpg'))
+      end
+    end
+
+    attr_accessor :content_type
+    attr_accessor :filename
+    attr_accessor :data
+    attr_accessor :directory
+    attr_accessor :debug
+
+    def initialize(content_type, filename, data, directory=nil)
+      self.content_type = content_type
+      self.filename = filename
+      self.data = data
+      self.directory = directory
+      return nil
+    end
+
+    def debug?
+      (ImageVenue.debug or self.debug) ? true : false
+    end
+
+    def puts_debug(*args)
+      if self.debug?
+        puts(*args)
+        return true
+      else
+        return false
+      end
+    end
+
+    def data_io
+      @data_io ||= StringIO.new(self.data) if self.data.is_a?(String)
+      @data_io ||= self.data
+      return @data_io
+    end
+
+    def read(bytes=nil)
+      self.data_io.read(bytes)
+    end
+
+    def rewind
+      self.data_io.rewind
+    end
+
+    def size
+      if self.data.is_a?(String)
+        @size ||= self.data.length
+      elsif self.data.respond_to?(:size)
+        @size ||= self.data.size
+      elsif self.data.respond_to?(:length)
+        @size ||= self.data.length
+      end
+      return @size
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: imagevenue
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Michael Nowak
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-16 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.6"
+    version: 
+description: Accessing your ImageVenue account via a Ruby-Library. With support for listing, creating, deleting directories and listing, uploading and deleting files. Generates BB-Code or HTML-Code four you, too.
+email: michael.nowak@thexsystem.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- image_venue.rb
+- image_venue/authenticate.rb
+- image_venue/directory.rb
+- image_venue/file.rb
+- image_venue/net_http_get_extensions.rb
+- image_venue/net_http_post_extensions.rb
+- image_venue/upload.rb
+- image_venue/upload_file.rb
+has_rdoc: false
+homepage: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: imagevenue
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Accessing your ImageVenue account via a Ruby-Library
+test_files: []
+