smugmugr 0.3.0 → 0.3.1

data/lib/smugmugr.rb

@@ -1,32 +1,22 @@
 require 'rubygems'
 require 'curb'
-# TODO: look for json_pure, then json
 require 'json'
 require 'yaml'
 
-require 'smugmugr/base'
+require 'smugmugr/user'
 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
 
+# TODO: keep this?
 def logger
   @logger ||= if Module.constants.include?('RAILS_DEFAULT_LOGGER')
     RAILS_DEFAULT_LOGGER
   else
-    Logger.new('smugmugr.log')
+    Logger.new('simple_smugmug.log')
   end
 end

data/lib/smugmugr/album.rb

@@ -1,22 +1,18 @@
 module Smugmugr
-  class Album < Smugmugr::Base
-    attr_accessor :user, :id, :title, :key, :pub_key, :session_id
+  class Album
+    attr_accessor :user, :id, :title, :key, :pub_key, :session_id, :extras
     
     #############################################
     # 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,
+    @@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]
+    @@complex_attributes = [:Category, :Community, :Highlight, :SubCategory, :Template, :Theme, :Watermark]
       
     def initialize(user)
-      @extras = {}
       @user = user
     end
     
@@ -28,7 +24,7 @@ module Smugmugr
         args[:heavy] ||= false
         args[:extras] ||= []
         params = {
-          :method => smug_method + '.get'
+          :method => 'smugmug.albums.get'
         }
         params.merge!(:Heavy => args[:heavy].to_s) if args[:heavy]
         params.merge!(:Extras => args[:extras].collect(&:to_s).join(','))
@@ -38,30 +34,27 @@ module Smugmugr
       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)
+        albums = json["Albums"].map do |album|
+          album_from_json(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|
+      def album_from_json(json, user, extras=[])
+        a = Album.new(user)
+        a.id = json['id']
+        a.title = json['Title']
+        a.key = json['Key']
+        a.extras = {}
+        @@attributes.each{ |key|
           next unless json.has_key?(key.to_s)
           
-          album.extras[key] = if self.complex_attributes.include?(key)
+          a.extras[key] = if @@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"
+        a
       end
     end
     
@@ -70,21 +63,35 @@ module Smugmugr
     #############################################
     def images(*extras)
       extras = [extras] unless extras.is_a?(Array)
-      Smugmugr::Image.get(self, :extras => extras)
+      Image.get(self, :extras => extras)
+    end
+    
+    def call(params)
+      user.call(params)
     end
     
     def get_info
       params = {
-        :method => Smugmugr::Album.smug_method + '.getInfo',
+        :method => 'smugmug.albums.getInfo',
         :AlbumID => self.id,
         :AlbumKey => self.key
       }
-      json = call(params)
-      return Smugmugr::Album.album_from_json(self, json["Album"], user, Smugmugr::Album.attributes)
+      json = user.call(params)
+      return Album.album_from_json(json["Album"], user, @@attributes)
     end
     
-    def call(params)
-      @user.call(params)
+    def method_missing(method)
+      # check extras for method_name, MethodName
+      methods = [method.to_s.classify, method.to_s]
+      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) & @@attributes).empty?
+      
+      # otherwise, move along
+      super(method)
     end
     
     class Simple

data/lib/smugmugr/image.rb

@@ -1,24 +1,20 @@
 module Smugmugr
-  class Image < Smugmugr::Base
-    attr_accessor :album, :id, :key
+  class Image
+    attr_accessor :album, :id, :key, :extras
     
-    class_inheritable_reader :attributes
-    write_inheritable_attribute :attributes, [:id,:Key,:Album,:Altitude,:Caption,:Date,:Duration,:FileName,:Format,:Height,:Hidden,
+    @@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]
+    @@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)
+      Image.get(self.album, :extras => extras)
     end
     
     class << self
@@ -34,47 +30,53 @@ module Smugmugr
         params.merge!(:Extras => args[:extras].collect(&:to_s).join(',')) if args[:extras].any?
         
         json = album.call(params)
-        images_from_json(json, album, params[:Extras])
+        parse_response(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)
+      def parse_response(json, album, extra_params)
+        album = json['Album']
+        album['Images'].map{ |image_json|
+          image = Image.new(album)
+          image.id = image_json['id']
+          image.key = image_json['Key']
+          image.extras = {}
+          @@attributes.each{ |key|
+            next unless image_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.extras[key] = if @@complex_attributes.include?(key)
+              Object.class_eval("Smugmugr::Image::#{key}").new(image_json[key.to_s])
+            else
+              image_json[key.to_s]
+            end
+          }
+          image
         }
-        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)
+    def method_missing(method)
+      # check extras for method_name, MethodName
+      methods = [method.to_s.classify, method.to_s]
+      
+      # handle _URL methods differently, .classify results in: "fancy_url".classify => "FancyUrl"
+      if method.to_s =~ /url|Url|URL/
+        methods << method.to_s.gsub(/url|Url/,'URL').classify
+      end
+      
+      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) & @@attributes).empty?
+      
+      # otherwise, move along
+      super(method)
     end
     
     class Album

data/lib/smugmugr/session.rb

@@ -1,15 +1,14 @@
 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={})
+    def initialize(api_key, user, args={})
       @user = user
-      @api_key = user.api_key
+      @api_key = api_key
       # TODO: externalize, make overrideable from ~/smugmugr.yml or RAILS_ROOT/config/smugmugr.yml
       attributes = {
         :host => 'api.smugmug.com',
@@ -61,7 +60,7 @@ module Smugmugr
       data = nil
       begin
         url = protocol + @host + build_url_request(params)
-        # puts "\nsending: #{url}\n"
+        puts "\nsending: #{url}\n"
         response = Curl::Easy.perform(url) do |easy|
           easy.headers.merge!(headers)
           easy.timeout = @timeout
@@ -75,7 +74,7 @@ module Smugmugr
       # check status of response
       json = JSON.parse(data)
       
-      unless json['stat'] == 'ok'
+      if json['stat'] != 'ok'
         # TODO: custom exception
         raise "error from smugmug: #{json.inspect}"
       end
@@ -103,11 +102,13 @@ module Smugmugr
       @user.filesize_limit = json['FileSizeLimit']
     end
     
+    private
+    
     def protocol
       return "http#{'s' if @use_ssl}://"
     end
     
-    # {:foo => 'bar', :baz => "blingy things"} => ['foo=bar','baz=blingy+things']
+    # {:foo => 'bar', :baz => "blingy things"} => ['foo=bar','baz=blingy%20things']
     def encode_params(raw_params)
       return raw_params.map{ |k,v|
         [k.to_s,CGI::escape(v.to_s)].join('=')
@@ -122,5 +123,4 @@ module Smugmugr
     end
     
   end
-end
-
+end

data/lib/smugmugr/user.rb

@@ -1,17 +1,15 @@
 module Smugmugr
-  class User < Smugmugr::Base
-    attr_accessor :credentials, :session_id, :session, :email, :password, :api_key
+  class User
+    attr_accessor :credentials, :session_id, :session, :email, :password
     # 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
+      @session = Smugmugr::Session.new(api_key, self, args[:session_args] || {})
     end
     
     def send_request_with_session(params)

data/smugmugr.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{smugmugr}
-  s.version = "0.3.0"
+  s.version = "0.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Rob Sterner"]
@@ -20,35 +20,19 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "lib/smugmugr.rb",
-     "lib/smugmugr/base.rb",
      "lib/smugmugr/album.rb",
-     "lib/smugmugr/category.rb",
-     "lib/smugmugr/community.rb",
-     "lib/smugmugr/family.rb",
-     "lib/smugmugr/friend.rb",
      "lib/smugmugr/image.rb",
      "lib/smugmugr/session.rb",
-     "lib/smugmugr/share_group.rb",
-     "lib/smugmugr/sub_category.rb",
-     "lib/smugmugr/theme.rb",
      "lib/smugmugr/user.rb",
-     "lib/smugmugr/watermark.rb",
      "smugmugr.gemspec",
      "spec/album_spec.rb",
-     "spec/category_spec.rb",
-     "spec/community_spec.rb",
-     "spec/family_spec.rb",
-     "spec/friend_spec.rb",
      "spec/image_spec.rb",
      "spec/response_stubs.rb",
      "spec/session_spec.rb",
-     "spec/sub_category_spec.rb",
      "spec/test_helper.rb",
-     "spec/theme_spec.rb",
-     "spec/user_spec.rb",
-     "spec/watermark_spec.rb",
+     "spec/user_spec.rb"
   ]
-  s.has_rdoc = false
+  s.has_rdoc = true
   s.homepage = %q{http://github.com/fermion/smugmugr}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
@@ -56,18 +40,11 @@ Gem::Specification.new do |s|
   s.summary = %q{smugmugr, the smugmug API wrapper}
   s.test_files = [
     "spec/album_spec.rb",
-     "spec/category_spec.rb",
-     "spec/community_spec.rb",
-     "spec/family_spec.rb",
-     "spec/friend_spec.rb",
      "spec/image_spec.rb",
      "spec/response_stubs.rb",
      "spec/session_spec.rb",
-     "spec/sub_category_spec.rb",
      "spec/test_helper.rb",
-     "spec/theme_spec.rb",
-     "spec/user_spec.rb",
-     "spec/watermark_spec.rb",
+     "spec/user_spec.rb"
   ]
 
   if s.respond_to? :specification_version then
@@ -75,14 +52,8 @@ Gem::Specification.new do |s|
     s.specification_version = 2
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<mocha>, [">= 0"])
-      s.add_development_dependency(%q<rspec>, [">= 0"])
     else
-      s.add_development_dependency(%q<mocha>, [">= 0"])
-      s.add_development_dependency(%q<rspec>, [">= 0"])
     end
   else
-    s.add_development_dependency(%q<mocha>, [">= 0"])
-    s.add_development_dependency(%q<rspec>, [">= 0"])
   end
 end

data/spec/album_spec.rb

@@ -1,51 +1,13 @@
 require File.dirname(__FILE__) + '/test_helper'
 require File.dirname(__FILE__) + '/response_stubs'
 
-describe("Smugmugr::Album") do
-  before(:all) do
-    @user = Smugmugr::User.new('anapikey')
+describe "Album" do
+  before do
+    @empty_album = mock('album')
+    @empty_album.stub!(:images).and_return([])
   end
   
-  describe("album_get") do
-    before(:all) do
-      @user.stubs(:call).returns(JSON.parse(albums_get))
-      @album = Smugmugr::Album.get(@user).first
-    end
-    
-    it "should have a title" do
-      @album.title.should == "My Birthday 2008"
-    end
-    
-    it "should be in Category 'Other'" do
-      @album.category.name.should == "Other"
-    end
+  it "should have no images" do
+    @empty_album.images.should be_empty
   end
-  
-  describe("albums_get_info") do
-    before(:all) do
-      @album = Smugmugr::Album.new(@user)
-      @user.stubs(:call).returns(JSON.parse(albums_get_info))
-      @album.get_info
-    end
-    
-    # spot checks that method_missing is working
-    it "should have 20 images" do
-      @album.image_count.should == 20
-    end
-    
-    it "should handle try to handle sumgumg's exceptions to camel case naming" do
-      # EXIF, for example
-      @album.exif.should be_true
-    end
-    
-    # spot checks that complex attributes function as expected
-    it "should be watermarked with name: Smugmug" do
-      @album.watermark.name.should == "SmugMug"
-    end
-    
-    it "should be in a category named 'Other' with id 0" do
-      @album.category.name.should == "Other"
-      @album.category.id.should == 0
-    end
-  end  
 end