smugmug 0.0.1

data/lib/smugmug/image/info.rb

@@ -0,0 +1,88 @@
+# -*- Mode: ruby; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+# $Hg: info.rb,v ecd3a25582a8 2007/08/11 07:17:53 boumenot $
+
+require 'smugmug/base'
+require 'smugmug/table'
+require 'smugmug/image/exif'
+
+module SmugMug
+    module Image
+        class Info < Base
+            attr_reader :album, :doc
+
+            def initialize(smugmug, album, doc)
+                super(smugmug)
+                @album, @doc = album, doc
+                self.class.table = MethodTable.new(Info.data(), smugmug.account_type, self)
+            end
+
+            ## overrides
+
+            def method
+                return 'smugmug.images.getInfo'
+            end
+
+            def fetch
+                params = {}
+                # params[:Password] = album.password
+                params[:ImageID]  = image_id
+
+                return super(params)
+            end
+
+            ## methods
+
+            def <=>(rhs)
+                return self.file_name <=> rhs.file_name
+            end
+
+            def delete
+                raise RuntimeError, "method is not yet implemented"
+            end
+
+            def stats
+                @stats = Stats.new(@smugmug, self) if @stats.nil?
+                return @stats
+            end
+
+            def exif
+                @exif = Exif.new(@smugmug, self) if @exif.nil?
+                return @exif
+            end
+
+            ## accessors
+
+            # FIXME: needed to prevent infinite recursion
+            def image_id()  return self.class.table.get(@doc, :image_id)  ; end
+
+            def Info.data
+                return %q{
+<smugmug>
+    <AlbumID         type="int"     xpath="//Album/attribute::id"/>
+    <ImageID         type="int"     xpath="//Image/attribute::id"/>
+    <Position        type="int"/>
+    <Serial          type="int"/>
+    <Size            type="int"/>
+    <Width           type="int"/>
+    <Height          type="int"/>
+    <LastUpdated/>
+    <Caption/>
+    <FileName/>
+    <MD5Sum/>
+    <Watermark       type="int"/>
+    <Format/>
+    <Keywords/>
+    <Date/>
+    <OriginalURL/>
+    <LargeURL/>
+    <MediumURL/>
+    <SmallURL/>
+    <ThumbURL/>
+    <TinyURL/>
+    <AlbumURL/>
+</smugmug>
+}
+            end
+        end
+    end
+end    

data/lib/smugmug/image/stats.rb

@@ -0,0 +1,32 @@
+# -*- Mode: ruby; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+# $Hg$
+
+require 'smugmug/base'
+
+module SmugMug
+    module Image
+        class Stats < BaseStats
+            attr_reader :doc, :image
+            def initialize(smugmug, image)
+                super(smugmug)
+                @image = image
+            end
+
+            ## overrides
+
+            def method
+                return 'smugmug.images.getStats'
+            end
+
+            def fetch
+                params = {}
+                params[:ImageID] = image.image_id
+
+                super(params)
+            end
+
+            ## methods
+            ## accessors
+        end
+    end
+end

data/lib/smugmug/images.rb

@@ -0,0 +1,52 @@
+# -*- ruby -*-
+# $Hg: images.rb,v a116fa71e3fb 2007/08/11 07:43:48 boumenot $
+
+require 'forwardable'
+require 'smugmug/base'
+require 'smugmug/image/info'
+
+module SmugMug
+    class Images < Base
+        include Enumerable
+
+        extend Forwardable
+        def_delegator :@images, :each, :each
+        def_delegator :@images, :any?, :any?
+        def_delegator :@images, :size, :size
+
+        attr_reader :album, :doc
+        
+        def initialize(smugmug, album)
+            super(smugmug)
+
+            @album  = album
+            @images = []
+
+            @doc = fetch()
+
+            @doc.elements.each('//Images/Image') do |x|
+                @images << Image::Info.new(smugmug, album, REXML::Document.new(x.to_s))
+                $log.info('Images#initialize') { "Added image ID #{@images[-1].image_id}" }
+            end
+        end
+
+        ## overrides
+
+        def method
+            return 'smugmug.images.get'
+        end
+
+        def method_missing(sym, *args)
+            raise NoMethodError.new("undefined method `#{sym}' for " +
+                                    "#{self.inspect}:#{self.class.name}")
+        end
+
+        def fetch
+            params = {}
+            # params[:Password] = XXX
+            params[:AlbumID] = album.album_id
+            
+            return super(params)
+        end
+    end
+end

data/lib/smugmug/table.rb

@@ -0,0 +1,133 @@
+# -*- Mode: ruby; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+# $Hg: table.rb,v f2af7d25fd90 2007/08/11 07:20:47 boumenot $
+
+require 'rexml/document'
+
+module SmugMug
+    class MethodTable
+        include Enumerable
+
+        attr_reader :account_type, :klass, :table
+        def initialize(xml, account_type, klass)
+            parse(xml)
+            @account_type = account_type
+            @klass = klass
+        end
+
+        def get(doc, sym)
+            unless element?(sym)
+                raise NoMethodError.new("undefined method '#{sym}' for " +
+                                        "#{self.inspect}:#{self.class.name}")
+            end
+
+            method = alias?(sym) ? alias_to_method(sym) : sym
+
+            # XXX: add an exception to handle this case!
+            unless permission?(method)
+                raise "an account type of #{account_type} cannot access this method, " +
+                       "which requires at least #{account(method)}"
+            end
+
+            val = REXML::XPath.first(doc, table[method][:xpath])
+            return nil if val.nil?
+            return convert_to_type(method, val.text.to_s) if val.respond_to?(:text)
+            return convert_to_type(method, val.to_s)
+        end
+
+        def each
+            @table.sort {|a,b| a.to_s <=> b.to_s }.each do |k,v|
+                next if @table[k].has_key?(:alias)
+                next unless permission?(k) 
+
+                yield k, v
+            end
+        end
+
+        private
+
+        def standard?
+            return account_type.downcase == 'standard'
+        end
+
+        def power?
+            return account_type.downcase == 'power'
+        end
+
+        def pro?
+            return account_type.downcase == 'pro'
+        end
+
+        def parse(xml)
+            @table = {}
+
+            doc = REXML::Document.new(xml)
+            doc.root.elements.each do |element|
+                sym = element.name.to_sym
+                @table[sym] ||= {}
+
+                element.attributes.each do |k,v|
+                    @table[sym][k.to_sym] = v.to_s
+                end
+
+                @table[sym][:xpath]   ||= "//#{sym.to_s}"
+                @table[sym][:type]    ||= "string"
+                @table[sym][:account] ||= "standard"
+
+                _alias(sym)
+            end
+        end
+
+        def _alias(method)
+            sym = method.to_s.gsub(/([a-z0-9])([A-Z])/) { "#{$1}_#{$2}" }.downcase
+            sym += '?' if @table[method][:type] == 'boolean'
+            sym = sym.to_sym
+
+            @table[sym] = {}
+            @table[sym][:alias] = method
+        end
+
+        def alias?(method)
+            return @table[method].has_key?(:alias)
+        end
+
+        def alias_to_method(method)
+            return @table[method][:alias]
+        end
+
+        def convert_to_type(sym, val)
+            puts "sym=#{sym.to_s} val=#{val}" if sym.to_s == 'test_id'
+            case xtype(sym)
+            when 'boolean': return (val.to_i == 0) ? false : true
+            when 'float':   return val.to_f
+            when 'int':     return val.to_i
+            else            return val.to_s
+            end
+        end
+
+        def permission?(sym)
+            case account(sym)
+            when 'standard': return (standard? or power? or pro?)
+            when 'power':    return (power? or pro?)
+            when 'pro':      return pro?
+            else
+                raise "Do not understand an account type of '#{account(sym)}' for method #{sym.to_s}!"
+            end
+        end
+
+        def element?(sym)
+            return table.has_key?(sym)
+        end
+
+        def xpath(sym)
+            return @table[sym][:xpath]
+        end
+
+        def xtype(sym)
+            return @table[sym][:type]
+        end
+
+        def account(sym)
+            return @table[sym][:account]
+        end
+    end
+end

data/lib/smugmug/util.rb

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+# $Hg$
+
+class File
+    def File.write(filename, data, offset=0)
+
+        File.open(filename, 'w') do |fh|
+            fh.seek(offset)
+            fh.write(data)
+        end
+    end
+end

data/test/album.rb

@@ -0,0 +1,359 @@
+# -*- Mode: ruby; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+# $Hg$
+
+require 'test/unit'
+require 'smugmug'
+require 'smugmug/album/info'
+require 'smugmug/album/stats'
+
+
+class TC_AlbumInfo < Test::Unit::TestCase
+    def setup
+        $smugmug.each do |album|
+            @album = album
+            break
+        end
+    end
+
+    def teardown
+    end
+
+    def test_raise_no_method
+        assert_raises(NoMethodError) { @album.No_SmugMug_Method }
+    end
+
+    ## ----------
+    ## accessors
+
+    def test_method
+        assert_equal('smugmug.albums.getInfo', @album.method)
+    end
+
+    def test_each_album
+        arr = %w{One Two Three}
+        $smugmug.each do |album|
+            assert_equal("Gallery #{arr.shift}", album.title)
+        end
+    end
+
+    def test_delegation
+        assert_equal(3, $smugmug.size)
+        assert($smugmug.any?)
+        assert_equal(3, @album.size)
+        assert(@album.any?)
+    end
+
+    ## ----------
+    ## dynamic accessors (method_missing)
+
+    ## Boolean ###############################################
+
+    def test_Public
+        val = @album.Public
+        assert_equal(true, val)
+        assert_kind_of(TrueClass, val)
+        assert_equal(val, @album.public?)
+    end
+
+     def test_Printable
+         val = @album.Printable
+         assert_equal(true, val)
+         assert_kind_of(TrueClass, val)
+         assert_kind_of(TrueClass, @album.printable?)
+         assert_equal(val, @album.printable?)
+     end
+
+     def test_Filenames
+         val = @album.Filenames
+         assert_equal(false, val)
+         assert_kind_of(FalseClass, val)
+         assert_kind_of(FalseClass, @album.filenames?)
+         assert_equal(val, @album.filenames?)
+     end
+
+     def test_Comments
+         val = @album.Comments
+         assert_equal(true, val)
+         assert_kind_of(TrueClass, val)
+         assert_kind_of(TrueClass, @album.comments?)
+         assert_equal(val, @album.comments?)
+     end
+
+     def test_External
+         val = @album.External
+         assert_equal(false, val)
+         assert_kind_of(FalseClass, val)
+         assert_kind_of(FalseClass, @album.external?)
+         assert_equal(val, @album.external?)
+     end
+
+     def test_Originals
+         val = @album.Originals
+         assert_equal(true, val)
+         assert_kind_of(TrueClass, val)
+         assert_kind_of(TrueClass, @album.originals?)
+         assert_equal(val, @album.originals?)
+     end
+
+     def test_EXIF
+         val = @album.EXIF
+         assert_equal(true, val)
+         assert_kind_of(TrueClass, val)
+         assert_kind_of(TrueClass, @album.exif?)
+         assert_equal(val, @album.exif?)
+     end
+
+     def test_Share
+         val = @album.Share
+         assert_equal(true, val)
+         assert_kind_of(TrueClass, val)
+         assert_kind_of(TrueClass, @album.share?)
+         assert_equal(val, @album.share?)
+     end
+
+     def test_SortDirection
+         val = @album.SortDirection
+         assert_equal(false, val)
+         assert_kind_of(FalseClass, val)
+         assert_kind_of(FalseClass, @album.sort_direction?)
+         assert_equal(val, @album.sort_direction?)
+     end
+
+     def test_FamilyEdit
+         val = @album.FamilyEdit
+         assert_equal(false, val)
+         assert_kind_of(FalseClass, val)
+         assert_kind_of(FalseClass, @album.family_edit?)
+         assert_equal(val, @album.family_edit?)
+     end
+
+     def test_FriendEdit
+         val = @album.FriendEdit
+         assert_equal(false, val)
+         assert_kind_of(FalseClass, val)
+         assert_kind_of(FalseClass, @album.friend_edit?)
+         assert_equal(val, @album.friend_edit?)
+     end
+
+     def test_HideOwner
+         val = @album.HideOwner
+         assert_equal(false, val)
+         assert_kind_of(FalseClass, val)
+         assert_kind_of(FalseClass, @album.hide_owner?)
+         assert_equal(val, @album.hide_owner?)
+     end
+
+     def test_CanRank
+         val = @album.CanRank
+         assert_equal(true, val)
+         assert_kind_of(TrueClass, val)
+         assert_kind_of(TrueClass, @album.can_rank?)
+         assert_equal(val, @album.can_rank?)
+     end
+
+     def test_Clean
+         assert_raises(RuntimeError) { @album.Clean }
+     end
+
+     def test_SmugSearchable
+         val = @album.SmugSearchable
+         assert_equal(false, val)
+         assert_kind_of(FalseClass, val)
+         assert_kind_of(FalseClass, @album.smug_searchable?)
+         assert_equal(val, @album.smug_searchable?)
+     end
+
+     def test_WorldSearchable
+         val = @album.WorldSearchable
+         assert_equal(false, val)
+         assert_kind_of(FalseClass, val)
+         assert_kind_of(FalseClass, @album.world_searchable?)
+         assert_equal(val, @album.world_searchable?)
+     end
+
+
+     ## Fixnum ################################################
+
+     def test_AlbumID
+         val = @album.AlbumID
+         assert_equal(1001, val)
+         assert_kind_of(Fixnum, val)
+         assert_kind_of(Fixnum, @album.album_id)
+         assert_equal(val, @album.album_id)
+     end
+
+     def test_HighlightID
+         val = @album.HighlightID
+         assert_equal(0, val)
+         assert_kind_of(Fixnum, val)
+         assert_kind_of(Fixnum, @album.highlight_id)
+         assert_equal(val, @album.highlight_id)
+     end
+
+     def test_CommunityID
+         val = @album.CommunityID
+         assert_equal(0, val)
+         assert_kind_of(Fixnum, val)
+         assert_kind_of(Fixnum, @album.community_id)
+         assert_equal(val, @album.community_id)
+     end
+
+     def test_CategoryID
+         val = @album.CategoryID
+         assert_equal(47, val)
+         assert_kind_of(Fixnum, val)
+         assert_kind_of(Fixnum, @album.category_id)
+         assert_equal(val, @album.category_id)
+     end
+
+     def test_ImageCount
+         val = @album.ImageCount
+         assert_equal(3, val)
+         assert_kind_of(Fixnum, val)
+         assert_kind_of(Fixnum, @album.image_count)
+         assert_equal(val, @album.image_count)
+     end
+
+     def test_Position
+         val = @album.Position
+         assert_equal(1, val)
+         assert_kind_of(Fixnum, val)
+         assert_kind_of(Fixnum, @album.position)
+         assert_equal(val, @album.position)
+     end
+
+
+     ## String ################################################
+
+#      def test_CategoryTitle
+#          val = @album.CategoryTitle
+#          assert_equal('Children', val)
+#          assert_kind_of(String, val)
+#          assert_kind_of(String, @album.category_title)
+#          assert_equal(val, @album.category_title)
+#      end
+
+     def test_Description
+         val = @album.Description
+         assert_equal('description', val)
+         assert_kind_of(String, val)
+         assert_kind_of(String, @album.description)
+         assert_equal(val, @album.description)
+     end
+
+     def test_Keywords
+         val = @album.Keywords
+         assert_equal('keywords', val)
+         assert_kind_of(String, val)
+         assert_kind_of(String, @album.keywords)
+         assert_equal(val, @album.keywords)
+     end
+
+     def test_LastUpdated
+         val = @album.LastUpdated
+         assert_equal('1970-01-01 00:00:00', val)
+         assert_kind_of(String, val)
+         assert_kind_of(String, @album.last_updated)
+         assert_equal(val, @album.last_updated)
+     end
+
+
+     def test_Password
+         val = @album.Password
+         assert_equal('', val)
+         assert_kind_of(String, val)
+         assert_kind_of(String, @album.password)
+         assert_equal(val, @album.password)
+     end
+
+     def test_PasswordHint
+         val = @album.PasswordHint
+         assert_equal('', val)
+         assert_kind_of(String, val)
+         assert_kind_of(String, @album.password_hint)
+         assert_equal(val, @album.password_hint)
+     end
+
+     def test_SortMethod
+         val = @album.SortMethod
+         assert_equal('Position', val)
+         assert_kind_of(String, val)
+         assert_kind_of(String, @album.sort_method)
+         assert_equal(val, @album.sort_method)
+     end
+
+     def test_Title
+         val = @album.Title
+         assert_equal('Gallery One', val)
+         assert_kind_of(String, val)
+         assert_kind_of(String, @album.title)
+         assert_equal(val, @album.title)
+     end
+end
+
+class TC_AlbumStats < Test::Unit::TestCase
+    def setup
+        $smugmug.each do |album|
+            @stats = album.stats
+            break
+        end
+
+    end
+
+    def teardown
+    end
+
+    def test_method
+        assert('smugmug.albums.getStats', @stats.method)
+    end
+
+    def test_bytes
+        assert_kind_of(Fixnum, @stats.bytes)
+        assert_equal(234659, @stats.bytes)
+        assert_kind_of(Fixnum, @stats.Bytes)
+        assert_equal(234659, @stats.Bytes)
+    end
+
+    def test_medium
+        assert_kind_of(Fixnum, @stats.medium)
+        assert_equal(2, @stats.medium)
+        assert_kind_of(Fixnum, @stats.Medium)
+        assert_equal(2, @stats.Medium)
+    end
+
+    def test_original
+        assert_kind_of(Float, @stats.original)
+        assert_equal(0, @stats.original)
+        assert_kind_of(Float, @stats.original)
+        assert_equal(0, @stats.original)
+    end
+
+    def test_small
+        assert_kind_of(Fixnum, @stats.small)
+        assert_equal(0, @stats.small)
+        assert_kind_of(Fixnum, @stats.Small)
+        assert_equal(0, @stats.Small)
+    end
+
+      ## XXX: should I support this?
+#     def test_status
+#         assert_kind_of(String, @stats.status)
+#         assert_equal('Open', @stats.status)
+#         assert_kind_of(String, @stats.Status)
+#         assert_equal('Open', @stats.Status)
+#     end
+
+    def test_thumb
+        assert_kind_of(Fixnum, @stats.thumb)
+        assert_equal(2, @stats.thumb)
+        assert_kind_of(Fixnum, @stats.Thumb)
+        assert_equal(2, @stats.Thumb)
+    end
+
+    def test_tiny
+        assert_kind_of(Fixnum, @stats.tiny)
+        assert_equal(20, @stats.tiny)
+        assert_kind_of(Fixnum, @stats.Tiny)
+        assert_equal(20, @stats.Tiny)
+    end
+end