smugmugr 0.3.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Rob Sterner
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,60 @@
+h1. smugmugr
+
+A (he's the DJ, I'm the) wrapper for v1.2.2 of the SmugMug "JSON API":http://wiki.smugmug.net/display/API/API+1.2.2.
+
+Originally inspired by Scott White's simple_smugmug Rails plugin:
+http://github.com/scottwhite/simple_smugmug/tree/master
+
+Current version: 0.2.0
+
+h2. Roadmap
+
+h3. v1.0
+
+  * read-only (with and without login (password-based and OAuth)) bits
+
+h3. v2.0
+
+  * read-write
+
+h2. Usage
+
+The current highly opinionated way to use this gem is:
+
+user = Smugmugr::User.new(api_key, :email => 'foo@example.com', :password => 'secret')
+albums = user.albums
+images = albums.first.images
+
+As of v1.2.2 of the API, Smugmug allows the passing of an Extras parameter to allow customization of a call to your liking:
+
+"http://www.dgrin.com/showthread.php?t=90636":http://www.dgrin.com/showthread.php?t=90636
+
+Taking advantage of this is a cinch with smugmugr:
+
+albums = user.albums(:SmugSearchable,:LastUpdated,:ImageCount)
+
+will yield:
+
+albums.first.extras => {:ImageCount=>29, :LastUpdated=>"2009-05-16 15:23:11", :SmugSearchable=>true}
+
+Also:
+
+albums.first.last_updated => "2009-05-16 15:23:11"
+albums.first.LastUpdated => "2009-05-16 15:23:11"
+
+albums.first.image_count => 29
+albums.first.ImageCount => 29
+
+h3. TODO
+  * TESTS: added rspec requires and shell spec classes.
+  * TBD
+
+h3. Author(s)
+
+Written by "Rob Sterner":http://github.com/fermion = "robsterner.com":http://robsterner.com
+
+h3. Copyright
+
+Released under the MIT license.
+
+Copyright (c) 2009 Rob Sterner. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'rake'
+require 'spec/rake/spectask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "smugmugr"
+    gem.summary = %Q{smugmugr, the smugmug API wrapper}
+    gem.email = "rob.sterner@gmail.com"
+    gem.homepage = "http://github.com/fermion/smugmugr"
+    gem.authors = ["Rob Sterner"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+desc 'Default: run unit specs.'
+task :default => :spec
+ 
+desc 'Test the smugmugr gem.'
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ["-c"]
+end
+
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "smugmugr #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/smugmugr/album.rb

@@ -0,0 +1,134 @@
+module Smugmugr
+  class Album < Smugmugr::Base
+    attr_accessor :user, :id, :title, :key, :pub_key, :session_id
+    
+    #############################################
+    # all attributes available on an Album
+    #############################################
+    class_inheritable_reader :attributes
+    write_inheritable_attribute :attributes, [:id,:Key,:Backprinting,:CanRank,:Category,:Clean,:ColorCorrection,:Comments,:Community,
+      :Description,:EXIF,:External,:FamilyEdit,:Filenames,:FriendEdit,:Geography,:Header,:HideOwner,:Highlight,:ImageCount,:Larges,:LastUpdated,
+      :Originals,:Password,:PasswordHint,:Position,:Printable,:ProofDays,:Protected,:Public,:Share,:SmugSearchable,:SortDirection,
+      :SortMethod,:SquareThumbs,:SubCategory,:Template,:Theme,:Title,:UnsharpAmount,:UnsharpRadius,:UnsharpSigma,:UnsharpThreshold,
+      :Watermark,:Watermarking,:WorldSearchable,:X2Larges,:X3Larges,:XLarges]
+      
+    class_inheritable_reader :complex_attributes
+    write_inheritable_attribute :complex_attributes, [:Album, :Category, :Community, :Highlight, :SubCategory, :Template, :Theme, :Watermark]
+      
+    def initialize(user)
+      @extras = {}
+      @user = user
+    end
+    
+    #############################################
+    # class
+    #############################################
+    class << self
+      def get(user, args={})
+        args[:heavy] ||= false
+        args[:extras] ||= []
+        params = {
+          :method => smug_method + '.get'
+        }
+        params.merge!(:Heavy => args[:heavy].to_s) if args[:heavy]
+        params.merge!(:Extras => args[:extras].collect(&:to_s).join(','))
+        
+        json = user.call(params)
+        return albums_from_json(json, user, args[:extras])
+      end
+      
+      def albums_from_json(json, user, extra_params=[])
+        json["Albums"].map do |album|
+          album_from_json(Smugmugr::Album.new(user), album, user, extra_params)
+        end
+      end
+      
+      def album_from_json(album, json, user, extras=[])
+        album.id = json['id']
+        album.title = json['Title']
+        album.key = json['Key']
+        album.extras = {}
+        self.attributes.each{ |key|
+          next unless json.has_key?(key.to_s)
+          
+          album.extras[key] = if self.complex_attributes.include?(key)
+            Object.class_eval("Smugmugr::Album::#{key}").new(json[key.to_s])
+          else
+            json[key.to_s]
+          end
+        }
+        album
+      end
+      
+      def smug_method
+        "smugmug.albums"
+      end
+    end
+    
+    #############################################
+    # instance
+    #############################################
+    def images(*extras)
+      extras = [extras] unless extras.is_a?(Array)
+      Smugmugr::Image.get(self, :extras => extras)
+    end
+    
+    def get_info
+      params = {
+        :method => Smugmugr::Album.smug_method + '.getInfo',
+        :AlbumID => self.id,
+        :AlbumKey => self.key
+      }
+      json = call(params)
+      return Smugmugr::Album.album_from_json(self, json["Album"], user, Smugmugr::Album.attributes)
+    end
+    
+    def call(params)
+      @user.call(params)
+    end
+    
+    class Simple
+      attr_accessor :id, :name
+      def initialize(json)
+        self.id = json["id"]
+        self.name = json["Name"]
+      end
+    end
+    
+    class Category < Simple
+    end
+    
+    class Community < Simple
+    end
+    
+    class Highlight
+      attr_accessor :id, :key
+      def initialize(json)
+        self.id = json["id"]
+        self.key = json["Key"]
+      end
+    end
+    
+    class SubCategory < Simple
+    end
+    
+    class Template
+      attr_accessor :id
+      def initialize(json)
+        self.id = json["id"]
+      end
+    end
+    
+    class Theme
+      attr_accessor :id, :name, :type
+      def initialize(json)
+        self.id = json["id"]
+        self.name = json["Name"]
+        self.type = json["Type"]
+      end
+    end
+    
+    class Watermark < Simple
+    end
+  end
+end

data/lib/smugmugr/base.rb

@@ -0,0 +1,25 @@
+module Smugmugr
+  class Base
+    class_inheritable_reader :attributes
+    write_inheritable_attribute :attributes, []
+    
+    class_inheritable_reader :complex_attributes
+    write_inheritable_attribute :complex_attributes, []
+    
+    attr_accessor :extras
+    
+    def method_missing(method)
+      # check extras for method_name, MethodName
+      methods = [method.to_s.classify, method.to_s, method.to_s.downcase, method.to_s.upcase]
+      methods.each do |extras_attribute|
+        return self.extras[extras_attribute.to_sym] if self.extras.has_key?(extras_attribute.to_sym)
+      end
+      
+      # if it in @@attributes but not populated, return nil
+      return nil unless (methods.collect(&:to_sym) & self.class.attributes).empty?
+      
+      # otherwise, move along
+      super(method)
+    end
+  end
+end

data/lib/smugmugr/category.rb

@@ -0,0 +1,5 @@
+module Smugmugr
+  class Category < Smugmugr::Base
+    
+  end
+end

data/lib/smugmugr/community.rb

@@ -0,0 +1,5 @@
+module Smugmugr
+  class Community < Smugmugr::Base
+    
+  end
+end

data/lib/smugmugr/family.rb

@@ -0,0 +1,5 @@
+module Smugmugr
+  class Family < Smugmugr::Base
+    
+  end
+end

data/lib/smugmugr/friend.rb

@@ -0,0 +1,5 @@
+module Smugmugr
+  class Friend < Smugmugr::Base
+    
+  end
+end

data/lib/smugmugr/image.rb

@@ -0,0 +1,89 @@
+module Smugmugr
+  class Image < Smugmugr::Base
+    attr_accessor :album, :id, :key
+    
+    class_inheritable_reader :attributes
+    write_inheritable_attribute :attributes, [:id,:Key,:Album,:Altitude,:Caption,:Date,:Duration,:FileName,:Format,:Height,:Hidden,
+      :Keywords,:LargeURL,:LastUpdated,:Latitude,:Longitude,:MD5Sum,:MediumURL,:OriginalURL,:Position,:Serial,
+      :Size,:SmallURL,:ThumbURL,:TinyURL,:Video320URL,:Video640URL,:Video960URL,:Video1280URL,:Video1920URL,:Width,
+      :X2LargeURL,:X3LargeURL,:XLargeURL]
+    
+    class_inheritable_reader :complex_attributes
+    write_inheritable_attribute :complex_attributes, [:Album]
+    
+    def initialize(album)
+      @extras = {}
+      @album = album
+    end
+    
+    def get(*extras)
+      extras = [extras] unless extras.is_a?(Array)
+      Smugmugr::Image.get(self.album, :extras => extras)
+    end
+    
+    class << self
+      def get(album, args={})
+        args[:heavy] ||= false
+        args[:extras] ||= []
+        params = {
+          :method => smug_method + 'get',
+          :AlbumID => album.id,
+          :AlbumKey => album.key
+        }
+        params.merge!(:Heavy => args[:heavy]) if args[:heavy]
+        params.merge!(:Extras => args[:extras].collect(&:to_s).join(',')) if args[:extras].any?
+        
+        json = album.call(params)
+        images_from_json(json, album, params[:Extras])
+      end
+      
+      def smug_method
+        return "smugmug.images."
+      end
+      
+      def images_from_json(json, album, extra_params=[])
+        json['Album']['Images'].map{ |image_json|
+          image_from_json(Smugmugr::Image.new(album), image_json, extra_params)
+        }
+      end
+      
+      def image_from_json(image, json, extras=[])
+        image.id = json['id']
+        image.key = json['Key']
+        image.extras = {}
+        self.attributes.each{ |key|
+          next unless json.has_key?(key.to_s)
+
+          image.extras[key] = if self.complex_attributes.include?(key)
+            Object.class_eval("Smugmugr::Image::#{key}").new(json[key.to_s])
+          else
+            json[key.to_s]
+          end
+        }
+        image
+      end
+    end
+    
+    #############################################
+    # instance
+    #############################################    
+    def get_info
+      params = {
+        :method => Smugmugr::Image.smug_method + '.getInfo',
+        :ImageID => self.id,
+        :ImageKey => self.key
+      }
+      json = @album.call(params)
+      return Smugmugr::Image.image_from_json(self, json["Image"], Smugmugr::Image.attributes)
+    end
+    
+    class Album
+      attr_accessor :id, :key, :url
+      def initialize(json)
+        self.id = json["id"]
+        self.key = json["Key"]
+        self.url = json["URL"]
+      end
+    end
+  end
+end

data/lib/smugmugr/session.rb

@@ -0,0 +1,126 @@
+require 'curl'
+require 'json'
+require 'cgi'
+
+module Smugmugr
+  class Session
+    attr_accessor :params, :host, :port, :timeout, :retry, :use_ssl, :session_id
+    attr_accessor :api_path, :session, :api_key, :user, :attributes, :headers
+    
+    def initialize(user, args={})
+      @user = user
+      @api_key = user.api_key
+      # TODO: externalize, make overrideable from ~/smugmugr.yml or RAILS_ROOT/config/smugmugr.yml
+      attributes = {
+        :host => 'api.smugmug.com',
+        :port => 443,
+        :timeout => 10,
+        :retry => 1, # no retry for now
+        :use_ssl => true,
+        :api_path => '/services/api/json/1.2.2/',
+        :headers => {
+          "User-Agent" => 'smugmugr v0.0.1'
+        }
+      }
+      attributes.merge!(args)
+      attributes.each{|k,v|
+        self.send("#{k}=", v) if self.respond_to?(k)
+      }
+    end
+    
+    def establish_session
+      if user.email && user.password
+        establish_session_with_login
+      else 
+        establish_anonymous_session
+      end
+      return self
+    end
+    
+    def establish_anonymous_session
+      establish_new_session({:method => 'smugmug.login.anonymously'})
+    end
+    
+    def establish_session_with_login
+      establish_new_session({:method => 'smugmug.login.withPassword', 
+                             :EmailAddress => "#{user.email}", 
+                             :Password => "#{user.password}"})
+    end
+    
+    def establish_session_with_open_auth
+      raise "unimplemented"
+    end
+    
+    def get_session_id
+      @session ||= establish_session
+      return @session.session_id
+    end
+    
+    def call(params={}, with_session_id=true)
+      params.merge!(:SessionID => "#{get_session_id}") if with_session_id
+      data = nil
+      begin
+        url = protocol + @host + build_url_request(params)
+        # puts "\nsending: #{url}\n"
+        response = Curl::Easy.perform(url) do |easy|
+          easy.headers.merge!(headers)
+          easy.timeout = @timeout
+        end
+        
+        data = response.body_str unless response.nil?
+      rescue Timeout::Error => e
+        # TODO: custom exception
+        raise e
+      end
+      # check status of response
+      json = JSON.parse(data)
+      
+      unless json['stat'] == 'ok'
+        # TODO: custom exception
+        raise "error from smugmug: #{json.inspect}"
+      end
+      
+      return json
+    end
+    
+    def establish_new_session(params)
+      begin
+        json = call(params, false)
+        
+        set_user_data(json["Login"])
+        self.session_id = json["Login"]["Session"]["id"]
+      rescue => e
+        # TODO: custom exception
+      end      
+    end
+    
+    private
+    
+    def set_user_data(json)
+      @user.user_id = json["User"]["id"]
+      @user.nickname = json["User"]["NickName"]
+      @user.password_hash = json['PasswordHash']
+      @user.filesize_limit = json['FileSizeLimit']
+    end
+    
+    def protocol
+      return "http#{'s' if @use_ssl}://"
+    end
+    
+    # {:foo => 'bar', :baz => "blingy things"} => ['foo=bar','baz=blingy+things']
+    def encode_params(raw_params)
+      return raw_params.map{ |k,v|
+        [k.to_s,CGI::escape(v.to_s)].join('=')
+      }
+    end
+    
+    # returns everything except protocol/host
+    def build_url_request(params)
+      params.merge!(:APIKey => @api_key)
+      param_string = encode_params(params)
+      return @api_path + '?' + param_string.join('&')
+    end
+    
+  end
+end
+

data/lib/smugmugr/share_group.rb

@@ -0,0 +1,5 @@
+module Smugmugr
+  class ShareGroup < Smugmugr::Base
+    
+  end
+end

data/lib/smugmugr/sub_category.rb

@@ -0,0 +1,5 @@
+module Smugmugr
+  class SubCategory < Smugmugr::Base
+    
+  end
+end

data/lib/smugmugr/theme.rb

@@ -0,0 +1,5 @@
+module Smugmugr
+  class Theme < Smugmugr::Base
+    
+  end
+end

data/lib/smugmugr/user.rb

@@ -0,0 +1,34 @@
+module Smugmugr
+  class User < Smugmugr::Base
+    attr_accessor :credentials, :session_id, :session, :email, :password, :api_key
+    # set by smugmug response data
+    attr_accessor :user_id, :nickname, :password_hash, :filesize_limit
+    
+    def initialize(api_key, args={})
+      @credentials = {}
+      self.api_key = api_key
+      args.each{ |k,v|
+        self.send("#{k}=", v) if self.respond_to?(k)
+      }
+      @session = Smugmugr::Session.new(self, args[:session_args] || {})
+      return
+    end
+    
+    def send_request_with_session(params)
+      @session.send_request_with_session(params)
+    end
+    
+    def albums(*extras)
+      extras = [extras] unless extras.is_a?(Array)
+      Album.get(self, :extras => extras)
+    end
+    
+    def session_id
+      @session.session_id
+    end
+    
+    def call(params={})
+      @session.call(params)
+    end
+  end
+end

data/lib/smugmugr/watermark.rb

@@ -0,0 +1,5 @@
+module Smugmugr
+  class Watermark < Smugmugr::Base
+    
+  end
+end

data/lib/smugmugr.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'curb'
+# TODO: look for json_pure, then json
+require 'json'
+require 'yaml'
+
+require 'smugmugr/base'
+require 'smugmugr/album'
+require 'smugmugr/category'
+require 'smugmugr/community'
+require 'smugmugr/family'
+require 'smugmugr/friend'
+require 'smugmugr/image'
+require 'smugmugr/session'
+require 'smugmugr/share_group'
+require 'smugmugr/sub_category'
+require 'smugmugr/theme'
+require 'smugmugr/user'
+require 'smugmugr/watermark'
+
+
+module Smugmugr
+  # TODO: attempt to load from a configuration file
+end
+
+def logger
+  @logger ||= if Module.constants.include?('RAILS_DEFAULT_LOGGER')
+    RAILS_DEFAULT_LOGGER
+  else
+    Logger.new('smugmugr.log')
+  end
+end