smugmug 0.0.1

data/HISTORY

@@ -0,0 +1,2 @@
+=== 0.0.1 (08/10/2007)
+	* Initial relase.

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007 Christopher Boumenot
+
+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/MANIFEST

@@ -0,0 +1,48 @@
+HISTORY
+LICENSE
+MANIFEST
+README
+Rakefile
+bin/smcli
+bin/smugmug2sql
+doc/API
+doc/TODO
+lib/net/httpz.rb
+lib/smugmug.rb
+lib/smugmug/album/info.rb
+lib/smugmug/album/stats.rb
+lib/smugmug/albums.rb
+lib/smugmug/base.rb
+lib/smugmug/cache.rb
+lib/smugmug/config.rb
+lib/smugmug/image/exif.rb
+lib/smugmug/image/info.rb
+lib/smugmug/image/stats.rb
+lib/smugmug/images.rb
+lib/smugmug/table.rb
+lib/smugmug/util.rb
+test/album.rb
+test/config.rb
+test/httpz.rb
+test/image.rb
+test/login.rb
+test/runner.rb
+test/servlet.rb
+test/table.rb
+xml/canned
+xml/fail/empty.set.xml
+xml/fail/invalid.apikey.xml
+xml/fail/invalid.login.xml
+xml/fail/invalid.method.xml
+xml/fail/invalid.user.xml
+xml/fail/system.error.xml
+xml/standard/albums.get.xml
+xml/standard/albums.getInfo.xml
+xml/standard/albums.getStats.xml
+xml/standard/categories.get.xml
+xml/standard/images.get.xml
+xml/standard/images.getEXIF.xml
+xml/standard/images.getInfo.xml
+xml/standard/images.getStats.xml
+xml/standard/login.withHash.xml
+xml/standard/login.withPassword.xml

data/README

@@ -0,0 +1,30 @@
+= SmugMug
+
+* http://www.rubyforge.org/project/smugmug
+* mailto:boumenot+smugmug@gmail.com
+
+== DESCRIPTION:
+
+An interface to smugmug.com using their REST interface.
+
+== FEATURES/PROBLEMS:
+
+* smugmug currently support read only access, read-write support should follow
+soon.
+
+== SYNOPSIS:
+
+  sm = SmugMug::SmugMug.new('user@example.net', 'secret')
+  sm.each do |album|
+    puts album.title
+    album.each do |image|
+        puts "\t#{image.file_name}"
+    end
+  end
+
+== REQUIREMENTS:
+== INSTALL:
+
+== LICENSE:
+
+:include:LICENSE

data/Rakefile

@@ -0,0 +1,100 @@
+# -*- ruby -*-
+# Borrowed heavily from ferret's Rakefile.
+
+$:.unshift('./lib')
+require 'smugmug'
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+## Globals ######################################
+
+PKG_VERSION = SmugMug::VERSION
+PKG_FILES   = IO.read('MANIFEST').split
+
+CLEAN.include(FileList['test/*.log'])
+
+## Tasks ########################################
+
+task :default => :test
+
+task :MANIFEST do
+    system "hg manifest | egrep -ve '^\.hg' > MANIFEST"
+end
+
+task :TODO do
+    FileList['**/*.rb'].egrep /#.*(FIXME|TODO|XXX)/
+end
+
+task :clean do
+    rm_rf 'pkg'
+    rm_rf 'doc/html'
+end
+
+task :tag do
+    release = "smugmug-#{PKG_VERSION}"
+    $stderr.puts("hg -m 'tagging #{release}' #{release}")
+end
+
+task :test do
+    system('cd test && ruby runner.rb')
+end
+
+rd = Rake::RDocTask.new(:docs) do |rdoc|
+    rdoc.rdoc_dir = 'doc/html'
+    rdoc.title    = "SmugMug Library Documentation"
+    rdoc.options << '--line-numbers'
+    rdoc.options << '--inline-source'
+    rdoc.options << '--charset=utf-8'
+    rdoc.rdoc_files.include('README')
+    rdoc.rdoc_files.include('doc/API')
+    rdoc.rdoc_files.include('doc/TODO')
+    rdoc.rdoc_files.include('LICENSE')
+    rdoc.rdoc_files.include('bin/smugmug2sql')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+## Gem ##########################################
+
+spec = Gem::Specification.new do |s|
+    ## basic
+    s.name = 'smugmug'
+    s.version = PKG_VERSION
+    s.summary = 'SmugMug REST library'
+    s.description = <<-EOT
+    ruby-smugmug is a library to interface with smugmug.com using their 
+    REST interface.
+EOT
+
+    ## dependency/requirements
+    s.files = PKG_FILES
+    s.bindir = 'bin'
+    #s.executables = %w{smugmug2sql}
+
+    ## project details
+    s.author = 'Christopher Boumenot'
+    s.email = 'boumenot@gmail.com'
+    s.homepage = 'http://www.rubyforge.org/projects/smugmug'
+    s.rubyforge_project = 'smugmug'
+
+    ## rdoc
+    s.has_rdoc = true
+    s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
+    s.rdoc_options << '--title' << 'SmugMug REST Library'
+    s.rdoc_options << '--main' << 'README'
+    s.rdoc_options << '--line-numbers'
+    s.rdoc_options << 'doc/TODO'
+    s.rdoc_options << 'doc/API'
+end
+
+package_task = Rake::GemPackageTask.new(spec) do |pkg|
+    unless RUBY_PLATFORM =~ /mswin/
+        pkg.need_tar = true
+    end
+end
+
+# vim: syntax=Ruby

data/bin/smcli

@@ -0,0 +1,225 @@
+#!/usr/bin/env ruby
+# $Hg: smcli,v f6ac7888e7aa 2007/07/17 14:23:26 boumenot $
+#
+# TODO: finish this, it does not work.
+# SmugMug CLI
+
+require 'forwardable'
+require 'logger'
+require 'net/http'
+require 'readline'
+require 'rexml/document'
+
+require 'smugmug'
+
+class Cache
+    def initialize
+        @cache = Hash.new
+    end
+
+    def cache(path, data)
+        @cache[path] ||= Hash.new
+        @cache[path]['valid'] = true
+        @cache[path]['data']  = data
+    end
+
+    def invalidate(path)
+        if @cache.has_key?(path)    
+            @cache[path]['valid'] = false
+        end
+    end
+
+    def cached?(path)
+        if @cache.has_key?(path)
+            return @cache[path]['valid']
+        end
+        return false
+    end
+end
+
+class Context
+    OFFSET_ROOT  = 0
+    OFFSET_ALBUM = 1
+    OFFSET_IMAGE = 2
+    OFFSET_INFO  = 3
+    OFFSET_FILE  = 4
+
+    def initialize
+        @path = Array.new
+    end
+
+    def leafs
+        return @path.size()
+    end
+
+    def [](i)
+        return @path[i]
+    end
+
+    def path
+        return @path.join('/')
+    end
+
+    def cd(path)
+        p = Array.new(@path)
+        q = path.split('/')
+
+        q.each do |d|
+            case d
+            when '.' 
+                next
+            when '..'
+                if p.any?
+                    p.shift
+                else
+                    raise ContextError, "invalid cd"
+                end
+            else
+                p.push(d)
+                unless valid?(p)
+                    raise ContextError, "invalid cd"
+                end
+            end
+        end
+        @path = p
+    end
+
+    def root_p()  return self[OFFSET_ROOT]  ; end
+    def album_p() return self[OFFSET_ALBUM] ; end
+    def image_p() return self[OFFSET_IMAGE] ; end
+    def info_p()  return self[OFFSET_INFO]  ; end
+
+    # XXX: ... must stop self from getting to fancy ...
+    # XXX: ... must write code that is readable ...
+    def root
+        return $cache.cache(root_p())
+    end
+    def album
+        return $cache.cache(album_p())
+    end
+    def image
+        return $cache.cache(album_p() + '/' + image_p())
+    end
+    def info
+        return $cache.cache(album_p() + '/' + image_p() + '/' + info_p())
+    end
+    def current
+        case leafs()
+        when 1 : return root()
+        when 2 : return album()
+        when 3 : return image()
+        when 4 : return info()
+        else
+            raise ContextError, "invalid current, path=#{@path}"
+        end
+    end
+
+    private
+
+    def valid?(path)
+        if path.size() == 0 or path.size() >= OFFSET_FILE
+            return false
+        else
+            return $cache.cached?(path[OFFSET_ALBUM..path.size()].join('/'))
+        end
+    end
+end
+
+class Commands
+    def initialize
+        @context = Context.new()
+    end
+
+    # print a file to standard output
+    def cat(*args)
+        return if args.size != 2
+    end
+
+    # change directory
+    def cd(*args)
+        return unless args.any?
+        @context.cd(args.shift)
+    end
+
+    # print working directory
+    def pwd(*args)
+        return @context.path()
+    end
+
+    # return the date and time
+    def date(*args)
+        return Time.now()
+    end
+
+    # directory listing
+    def ls(*args)
+        if args.any?
+            args.each do |dir|
+                puts "#{dir}:"
+                temp = Context.new()
+                temp.cd(dir)
+                pp_listing(temp.current)
+                print "\n"
+            end
+        else
+            pp_listing(@context.current)
+        end
+    end
+
+    # def echo(*args) ; end
+    # def mv(*args) ; end
+    # def rm(*args) ; end
+
+    private
+
+    def pp_listing(ary)
+        ary.each {|x| puts x}
+    end
+end
+
+def main
+    username = ARGV.shift
+    password = ARGV.shift
+
+    $log = Logger.new('smcli.log')
+  
+    $sm = SmugMug::SmugMug.new
+    $sm.login(username, password)
+
+    comm = Commands.new
+    diff = comm.methods = Object.methods
+    Readline.completion_proc = lamba do |s|
+        p.find_all { |e| e.match(s) }
+    end
+
+    loop do
+        line = Readline.readline("smcli> ", true)
+        next unless line.any?
+
+        if line.nil?
+            print "\n"
+            Kernel.exit
+        end
+
+        begin
+            args = line.split
+            command = args.shift
+
+            if comm.respond_to?(command)
+                comm.send(commands, *args)
+            else
+                puts "Do not understand the command #{command}"
+            end
+        rescue SmugMug::SmugMugError => e
+            puts "SmugMug: #{e}"
+            Kernel.exit
+        end
+    end
+end
+
+if __FILE__ == $0
+    main()
+end
+
+# vim:expandtab
+# vim:autoindent

data/bin/smugmug2sql

@@ -0,0 +1,158 @@
+#!/usr/bin/env ruby
+# -*- Mode: ruby; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+# $Hg$
+#
+# smugmug2sql converts SmugMug data into SQL, and inserts the data into a 
+# SQLite3 database.  Data for albums, images, and exif are stored in the
+# database.  By moving the data to database it makes it much faster and 
+# easier to access the data.  Because the data are in a database, one can
+# build and execute complex queries against the data. For example, one could 
+# select all photos taken between 5/1/2007, and # 5/31/2007.  
+
+require 'dbi'
+require 'forwardable'
+require 'optparse'
+require 'smugmug'
+
+module SmugMug
+    class MethodTable
+        def sql_type(method)
+            case xtype(method)
+            when 'boolean': return 'INTEGER'
+            when 'float':   return 'REAL'
+            when 'int':     return 'INTEGER'
+            else            return 'TEXT'
+            end
+        end
+
+        def sql_schema
+            return @schema unless @schema.nil? 
+
+            @schema = "CREATE TABLE #{self.klass.sql_table_name} (\n"
+            each do |k,v| 
+                @schema += "\t#{k} #{sql_type(k)},\n"
+            end
+            @schema[-2..-1] = ')'
+
+            $log.info("#{klass}#sql_schema") { @schema }
+            return @schema
+        end
+    end
+
+    class Base
+        def to_sql
+            stmt = "INSERT INTO #{sql_table_name} VALUES(\n"
+
+            self.class.table.each do |k,v|
+                val = self.send(k.to_sym)
+                stmt += (val.nil?) ? %Q{\tNULL,\n} : %Q{\t"#{val}",\n}
+            end
+            stmt[-2..-1] = ')'
+
+            $log.info("#{self.class}#to_sql") { stmt }
+            return stmt
+        end
+    end
+
+    module Album
+        class Info
+            def sql_table_name() return 'album' end
+        end
+    end
+
+    module Image
+        class Info
+            def sql_table_name() return 'image' end
+        end
+        class Exif
+            def sql_table_name() return 'exif' end
+        end
+    end
+end
+
+
+def do_SQL(dbh, klass)
+    return if $sql_replay.has_key?(klass.to_sql)
+
+    unless $init.has_key?(klass.sql_table_name)
+        $init[klass.sql_table_name] = 'true'
+        dbh.do(klass.class.table.sql_schema) 
+    end
+
+    dbh.do(klass.to_sql)
+    $sql_replay[klass.to_sql] = true
+
+    sleep rand(5) + 1 # be kind...
+end
+
+def main()
+    options = {}
+    OptionParser.new do |opts|
+        opts.on("-p", "--password PASSWORD", "SmugMug password") do |v|
+            options[:password] = v
+        end
+        opts.on("-u", "--username USERNAME", "SmugMug email address") do |v|
+            options[:username] = v
+        end
+        opts.on("-d", "--database DATABASE", "name of the database file") do |v|
+            options[:database ] = v
+        end
+        opts.on("-l", "--logging FILENAME", "enable logging to FILENAME") do |v|
+            $log = Logger.new(v)
+        end
+        opts.on_tail("-h", "--help", "Show this message") do
+            puts opts
+            Kernel.exit
+        end
+    end.parse!
+    
+    if options.has_key?(:username) ^ options.has_key?(:password)
+        puts "%Error: Must specify both --username and --password"
+        raise SystemExit
+    end
+
+    sm = if options.has_key?(:username)
+        SmugMug::SmugMug.new(options[:username], options[:password])
+    else
+        SmugMug::SmugMug.new
+    end
+
+    db_file = options[:database] || 'smugmug.db'
+
+    $init = {}
+    $sql_replay = {}
+
+    begin
+        dbh = DBI.connect("DBI:SQLite3:#{db_file}")
+
+        # Let me apologize up front to anyone reading this loop.
+        # SmugMug.com gets through a few albums and then starts 
+        # timing out my connections.  This is my attempt to  deal
+        # with that issue.
+        sm.each do |album|
+            begin
+                do_SQL(dbh, album)
+                album.each do |image|
+                    begin
+                        do_SQL(dbh, image)
+                        do_SQL(dbh, image.exif)
+                    rescue Errno::ETIMEDOUT
+                        sleep 30
+                        redo
+                    end
+                end
+            rescue Errno::ETIMEDOUT
+                sleep 30
+                redo
+            end
+        end
+    rescue DBI::DatabaseError => e
+        puts "%Error: #{e.err} -> #{e.errstr}"
+    ensure
+        dbh.disconnect if dbh
+    end
+end
+
+if $0 == __FILE__ 
+    main()
+end