smugmugapi 0.9.2 → 0.9.5

data/History.txt

@@ -1,3 +1,14 @@
+== 0.9.5 / 2007-12-09
+
+* Added cookie handling to REST calls
+* Added Feed wrapper for searching
+
+== 0.9.3 / 2007-12-05
+
+* Added proper mime/content-type encoding for uploads
+* Added handy rake task for tagging releases
+* added default VERSION for release gem 
+
 == 0.9.2 / 2007-12-04
 
 * Fixed "automatic" URL endpoint for 1.2.1 api

data/Rakefile

@@ -5,6 +5,8 @@ require 'hoe'
 require './lib/smugmugapi.rb'
 
 Hoe.new('smugmugapi', SmugMugAPI::VERSION) do |p|
+  ENV["VERSION"] ||= SmugMugAPI::VERSION
+  
   p.rubyforge_name = 'smugmugapi'
   p.author = 'Patrick Hurley'
   p.email = 'phurley@gmail.com'
@@ -12,4 +14,17 @@ Hoe.new('smugmugapi', SmugMugAPI::VERSION) do |p|
   p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
   p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
   p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.extra_deps << ['mime-types']
 end
+
+desc "Tag current trunk in subversion with the current version"
+task :tag_release do
+  puts "Tag trunk as #{ENV["VERSION"]}"
+  repo = nil
+  `svn info`.each_line do |line|
+    if line.match(/^Repository Root: (.*)/)
+      repo = $1
+    end
+  end
+  puts "svn copy #{repo}/trunk #{repo}/tags/#{ENV["VERSION"]} -m \"Tag release #{ENV["VERSION"]}\""
+end

data/examples/upload.rb

@@ -15,5 +15,7 @@ smugmug.login("phurley@gmail.com", IO.read('password')) do
   album = album.id
    
   puts smugmug.upload('mona_lisa.jpg', :album_id => album, :caption => "Wow it actually works")
+  # This works too, just send a movie everything else takes care of itself
+  # puts smugmug.upload('movie.avi', :album_id => album, :caption => "Wow it actually works")
   
 end

data/lib/smugmug/core.rb

@@ -9,18 +9,23 @@ class SmugMugAPI
   class << self
     USERAGENT = "SumMug Ruby API Library"
 
-    attr_writer :api_key, :agent, :api_version, :default_params
+    attr_writer :api_key, :agent, :api_version, :default_params, :cookies
+    attr_accessor :nickname
 
+    def cookies
+      @cookies ||= Hash.new
+    end
+    
     def default_params
       @default_params ||= { :APIKey => api_key }
     end
 
     def api_version
-      @api_version || '1.2.0'
+      @api_version ||= '1.2.0'
     end
-    
+
     def api_key
-      @api_key || 'RXcw7ywveg9pEj1n6HBJfuDXqsFsx4jw'
+      @api_key ||= 'RXcw7ywveg9pEj1n6HBJfuDXqsFsx4jw'
     end
 
     def api_path
@@ -42,24 +47,26 @@ class SmugMugAPI
       # get this information but this is a fairly exhaustive list 
       # and it will be easy to add to this as well
       %w(albums albumtemplates categories images login subcategories users 
-      
-         communities family friends orders pricing propricing sharegroups 
-         styles themes watermarks)
+
+      communities family friends orders pricing propricing sharegroups 
+      styles themes watermarks)
     end
-    
-    def get(passed_params, headers={}, transport='http')
+
+    def build_uri(passed_params, scheme='http')
       params = default_params.merge(passed_params)
 
-      url = transport + "://" + api_path + "?" +
+      url = scheme + "://" + api_path + 
+        "?" +
         params.map { |k,v| URI.encode("#{SmugMugAPI.camelize(k)}=#{v}") }.join("&")
       uri = URI.parse(url)
+    end
+    
+    def get(uri, headers={})
       headers['User-Agent'] ||= agent
       headers['Accept-Encoding'] ||= 'gzip, deflate'
-      
-      pp [:smugapi, params, headers, uri] if $DEBUG
-      
+
       http = Net::HTTP.new(uri.host, uri.port)
-      if transport == 'https'
+      if uri.scheme == 'https'
         http.use_ssl     = true
         http.verify_mode = OpenSSL::SSL::VERIFY_NONE
       end
@@ -69,43 +76,72 @@ class SmugMugAPI
       end
     end
 
-    def parse_response(response)
+    def parse_response(response, feed = false)
       puts "HTTP #{response.code}: #{response.message}" if $DEBUG
-      
+      if $DEBUG
+        response.each_header do |k,v|
+          puts "#{k}: #{v}"
+          p k if k.to_s.match(/cook/i)
+        end
+      end
+
       raise SmugMugAPI::Error.new("HTTP #{response.code}") unless response.code.to_i == 200
 
       body = case response['content-encoding']
-        when 'gzip'
-          Zlib::GzipReader.new(StringIO.new(response.body)).read 
-        when 'deflate'
-          Zlib::Inflate.inflate(response.body)
-        when nil
-          response.body
-        else
-          raise "Unknown encoding #{response['content-encoding']}"
+      when 'gzip'
+        Zlib::GzipReader.new(StringIO.new(response.body)).read 
+      when 'deflate'
+        Zlib::Inflate.inflate(response.body)
+      when nil
+        response.body
+      else
+        raise "Unknown encoding #{response['content-encoding']}"
+      end
+
+      if new_cookies = response.get_fields('Set-Cookie')
+        # not quite RFC 2109, but should be good enough for our needs
+        new_cookies.join(',').split(/,(?=[^;,]*=)|,$/).each do |cookie|
+          if cookie.match(/([^=]+)=([^;]+)/)
+            self.cookies[$1] = $2
+          end
+        end
       end
       
       doc = REXML::Document.new(body)
-      if doc.root.attributes['stat'] != 'ok'
+      if !feed && doc.root.attributes['stat'] != 'ok'
         err = doc.root.elements['/rsp/err']
         code = err.attributes['code']
         msg = err.attributes['msg']
+        puts body if $DEBUG
         raise SmugMugAPI::Error.new("#{code}: #{msg}")
       end
 
-      XMLStruct.new(doc)      
+      if feed
+        doc = doc.root
+      end
+      
+      XMLStruct.new(doc, feed)      
     end
-    
+
     def https_call(params={})
       call(params, 'https')
     end
-    
+
     def http_call(params={})
       call(params, 'http')
     end
+
+    def get_feed(feed)
+      uri = URI.parse(feed)
+      
+      # process to support passworded feeds
+      headers= { 'Cookie' => SmugMugAPI.cookies.map { |k,v| "#{k}=#{v}"}.join("; ") }
+      parse_response(get(uri, headers), true)
+    end
     
-    def call(params = {}, transport = "http")
-      parse_response(get(params, {}, transport))
+    def call(params = {}, scheme = "http")
+      uri = build_uri(params, scheme)
+      parse_response(get(uri, {}))
     end
   end
 end

data/lib/smugmug/logon.rb

@@ -1,6 +1,8 @@
 class SmugMugAPI
 
   def login(email, password)
+    self.nickname = email # it works here, or you can just set it manually
+    
     res = SmugMugAPI.https_call(
     :method => 'smugmug.login.withPassword',
     :EmailAddress => email,

data/lib/smugmug/upload.rb

@@ -1,4 +1,5 @@
 require 'digest/md5'
+require 'mime/types'
 require "pp"
 
 class SmugMugAPI
@@ -10,7 +11,7 @@ class SmugMugAPI
 
     Net::HTTP.start(uri.host, uri.port) do |http|
       headers = {
-        'Content-Type'  => 'image/jpeg',
+        'Content-Type'  => MIME::Types.type_for(base_name).to_s,
         'Content-Lenth' => image.size.to_s,
         'Content-MD5'   => Digest::MD5.hexdigest(image),
         'X-Smug-SessionID' => SmugMugAPI.default_params[:SessionID],

data/lib/smugmug/utility.rb

@@ -8,6 +8,7 @@ class SmugMugAPI
     str = str.gsub(/URL/i, "URL").gsub(/EXIF/i, "EXIF")
     str = str.gsub(/(?!^)ID$/i, "ID")
     str = str.gsub(/EXIF/i, "EXIF")
+    str = str.gsub(/MD5Sum/i, "MD5Sum")
     str = str.gsub(/X(.?)Large/i) { "X#{$1}Large" }
     str = "method" if str == "Method" #special case
     str

data/lib/smugmug/xmlstruct.rb

@@ -1,46 +1,54 @@
 
+
 class SmugMugAPI
   class XMLStruct
     include Enumerable
     
+    # hide Enumerable#entries
+    undef entries
+    
     def id(*args)
       method_missing(:id, *args)
     end
 
-    def initialize(xml)
-      if xml.is_a?(REXML::Document)
+    def initialize(xml, feed=false)
+      @feed = feed
+      if xml.is_a?(REXML::Document) && !feed
         @xml = xml.root.elements[2]
       else
         @xml = xml
       end
     end
 
-    def self.attrib_key(key)
+    def feed?
+      @feed
+    end
+    
+    def self.attrib_key(key, feed)
       case key
       when "Id", "id", :id
         "id"
       when Fixnum
         key
       else
-        SmugMugAPI.camelize(key)
+        if feed
+          key.to_s
+        else
+          SmugMugAPI.camelize(key)
+        end
       end
     end
     
     def [](attrib)
       if attrib.is_a?(Fixnum)
-        # puts "Finding #{attrib} hmmm: #{@xml.elements[attrib]}"
-        result = XMLStruct.new(@xml.elements[attrib])
-        # puts "Found #{result}"
-        result
+        XMLStruct.new(@xml.elements[attrib], @feed)
       else
-        # key = XMLStruct.attrib_key(attrib)
-        # puts "Searching for #{key}"
-        @xml.attributes[XMLStruct.attrib_key(attrib)]
+        @xml.attributes[XMLStruct.attrib_key(attrib, @feed)]
       end
     end
     
     def first
-      XMLStruct.new(@xml.elements[1])
+      XMLStruct.new(@xml.elements[1], @feed)
     end
     
     def size
@@ -52,31 +60,49 @@ class SmugMugAPI
     end
     
     def last
-      XMLStruct.new(@xml.elements[@xml.elements.size])
+      XMLStruct.new(@xml.elements[@xml.elements.size], @feed)
     end
     
     def []=(attrib,value)
-      @xml.attributes[XMLStruct.attrib_key(attrib)] = value
+      @xml.attributes[XMLStruct.attrib_key(attrib, @feed)] = value
     end
 
-    def each
-      @xml.elements.each do |xml|
-        yield XMLStruct.new(xml)
+    def each(path=nil)
+      if path
+        @xml.elements.each(path) do |xml|
+          yield XMLStruct.new(xml, @feed)
+        end
+      else
+        @xml.elements.each do |xml|
+          yield XMLStruct.new(xml, @feed)
+        end
       end
     end
-
+    
     def method_missing(*args)
-      method = SmugMugAPI.camelize(args.shift)
-      path = "#{method}"
-      if node = @xml.elements[path]
-        XMLStruct.new(node)
+      if @feed && args.first == :entries
+        entries = @xml.get_elements("//entry").map { |e| XMLStruct.new(e, true) }
       else
-        self[method]
+        path = XMLStruct.attrib_key(args.shift, @feed)
+        node = @xml.elements[path] rescue nil
+        if node
+          XMLStruct.new(node, @feed)
+        else
+          self[path]
+        end
       end
     end
 
     def to_s
+      @xml.text
+    end
+    
+    def to_xml
       @xml.to_s
     end
+    
+    def dump
+      @xml.write($stdout, 3, true)
+    end
   end
 end

data/lib/smugmugapi.rb

@@ -4,25 +4,42 @@ require File.join(File.dirname(__FILE__), "smugmug/xmlstruct")
 require File.join(File.dirname(__FILE__), "smugmug/exception")
 require File.join(File.dirname(__FILE__), "smugmug/upload")
 require File.join(File.dirname(__FILE__), "smugmug/logon")
+require File.join(File.dirname(__FILE__), "smugmug/feed")
 
 class SmugMugAPI
-  VERSION = "0.9.2"
+  VERSION = "0.9.5"
   
-  def initialize(base="smugmug")
+  def nickname=(name)
+    SmugMugAPI.nickname = name
+  end
+  
+  def initialize(base="smugmug", feed=false)
     @base = base
+    @feed = feed
   end
   
   def method_missing(method, *params)
     cmd = @base + "." + SmugMugAPI.camelize(method, false)
     if SmugMugAPI.groups.include?(method.to_s)
-      SmugMugAPI.new(cmd)
+      SmugMugAPI.new(cmd, @feed)
+    elsif [:global_feed, :user_feed].include?(method)
+      SmugMugAPI.new(cmd, method)
     else
-      param_hash = params.first || {}
-      SmugMugAPI.call(
-        { :method => cmd }.merge(param_hash)
-      )
+      
+      if @feed
+        process_feed(method, params)
+      else
+        process_api(cmd, params)
+      end
+      
     end  
   end
+  
+  def process_api(cmd, params)
+    param_hash = params.first || {}
+    SmugMugAPI.call( {:method => cmd}.merge(param_hash))
+  end
+
 end
 
 # added here for pretty interface

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: smugmugapi
 version: !ruby/object:Gem::Version 
-  version: 0.9.2
-date: 2007-12-05 00:00:00 -05:00
+  version: 0.9.5
+date: 2007-12-10 00:00:00 -05:00
 summary: A very light wrapper around the SmugMug REST API
 require_paths: 
 - lib
@@ -85,6 +85,15 @@ extensions: []
 requirements: []
 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
   version_requirement: