smile 0.3.1 → 0.4.0

data/.gitignore

@@ -1,5 +1,6 @@
 # Files
 *.swp
+*.swo
 *.jpg
 .DS_Store
 
@@ -11,4 +12,6 @@ rdoc/
 pkg/
 doc/
 
+*.gem
+.yardoc
 

data/Rakefile

@@ -1,7 +1,51 @@
 require 'rubygems'
 require 'rake'
-require 'metric_fu'
-require 'config/metric_fu_config'
+require 'date'
+
+#############################################################################
+##
+## Helper functions
+##
+##############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+    sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+desc "Run Shindo rake tasks"
+task :test do
+  sh "shindo #{Dir.glob( 'test/**/*_test.rb' ).join(' ')}"
+end
 
 begin
   require 'jeweler'
@@ -22,56 +66,7 @@ rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
 end
 
-# These are new tasks
-# These are new tasks
-begin
-  require 'rake/contrib/sshpublisher'
-  namespace :rubyforge do
-
-    desc "Release gem and RDoc documentation to RubyForge"
-    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
-
-    namespace :release do
-      desc "Publish RDoc to RubyForge."
-      task :docs => [:rdoc] do
-        config = YAML.load(
-            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
-        )
-
-        host = "#{config['username']}@rubyforge.org"
-        remote_dir = "/var/www/gforge-projects/cajun-gems/"
-        local_dir = 'rdoc'
-
-        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
-      end
-    end
-  end
-rescue LoadError
-  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
-end
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = true
-end
-
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/*_test.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
-end
-
-
-task :default => :test
+task :default => :test 
 
 require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
+:minor: 4
+:patch: 0
 :major: 0
-:minor: 3
-:patch: 1

data/bin/smile

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#!/usr/bin/enbin/smile
 # -*- mode: ruby -*-
 
 require 'optparse'

data/lib/smile/album.rb

@@ -1,88 +1,71 @@
 # The Album class will fetch any public/private album hosted on SmugMug.
-# The Album Objects will have the following fields on the response
 #
-# Result
+# the album objects will have the following fields on the response
 #
-# STANDARD RESPONSE
+# result
+#
+# standard response
+# 
 # 
-# array Albums
-#   Album
-#     integer id
-#     string Key
-#     string Title
-#     struct Category
-#       string id
-#       string Name
-#     string id
-#     string Name
-#     struct SubCategory
-#       string id
-#       string Name
-#     string id
-#     string Name
+# Album
+#   album_id
+#   album_key
+#   title
+#   category { id,  name }
+#   subcategory { id, name }
 #
-# HEAVY RESPONSE
+# HEAVY RESPONSE ( DEFAULT )
+#   
+# Album
+#   album_id
+#   album_key
+#   title
+#   category { id,  name }
+#   subcategory { id, name }
+#   string description
+#   string keywords
+#   boolean geography (owner)
+#   integer position
+#   struct hightlight (owner) { id }
+#   integer imagecount
+#   string lastupdated
+#   boolean header (owner, power & pro only)
+#   boolean clean (owner)
+#   boolean exif (owner)
+#   boolean filenames (owner)
+#   struct template (owner) { id }
+#   string sortmethod (owner)
+#   boolean sortdirection (owner)
+#   string password (owner)
+#   string passwordhint (owner)
+#   boolean public (owner)
+#   boolean worldsearchable (owner)
+#   boolean smugsearchable (owner)
+#   boolean external (owner)
+#   boolean protected (owner, power & pro only)
+#   boolean watermarking (owner, pro only)
+#   struct watermark (owner, pro only) { id }
+#   boolean hideowner (owner)
+#   boolean larges (owner, pro only)
+#   boolean xlarges (owner, pro only)
+#   boolean x2larges (owner)
+#   boolean x3larges (owner)
+#   boolean originals (owner)
+#   boolean canrank (owner)
+#   boolean friendedit (owner)
+#   boolean familyedit (owner)
+#   boolean comments (owner)
+#   boolean share (owner)
+#   boolean printable (owner)
+#   int colorcorrection (owner)
+#   integer proofdays (owner, pro only)
+#   string backprinting (owner, pro only)
+#   float unsharpamount (owner, power & pro only)
+#   float unsharpradius (owner, power & pro only)
+#   float unsharpthreshold (owner, power & pro only)
+#   float unsharpsigma (owner, power & pro only)
+#   struct community (owner) id
 #   
-# array Albums
-#   Album
-#     integer id
-#     string Key
-#     string Title
-#     struct Category
-#       string id
-#       string Name
-#     struct SubCategory
-#       string id
-#       string Name
-#     string Description
-#     string Keywords
-#     boolean Geography (owner)
-#     integer Position
-#     struct Hightlight (owner)
-#       string id
-#     integer ImageCount
-#     string LastUpdated
-#     boolean Header (owner, power & pro only)
-#     boolean Clean (owner)
-#     boolean EXIF (owner)
-#     boolean Filenames (owner)
-#     struct Template (owner)
-#       string id
-#     string SortMethod (owner)
-#     boolean SortDirection (owner)
-#     string Password (owner)
-#     string PasswordHint (owner)
-#     boolean Public (owner)
-#     boolean WorldSearchable (owner)
-#     boolean SmugSearchable (owner)
-#     boolean External (owner)
-#     boolean Protected (owner, power & pro only)
-#     boolean Watermarking (owner, pro only)
-#     struct Watermark (owner, pro only)
-#       string id
-#     boolean HideOwner (owner)
-#     boolean Larges (owner, pro only)
-#     boolean XLarges (owner, pro only)
-#     boolean X2Larges (owner)
-#     boolean X3Larges (owner)
-#     boolean Originals (owner)
-#     boolean CanRank (owner)
-#     boolean FriendEdit (owner)
-#     boolean FamilyEdit (owner)
-#     boolean Comments (owner)
-#     boolean Share (owner)
-#     boolean Printable (owner)
-#     int ColorCorrection (owner)
-#     boolean DefaultColor (owner, pro only)  deprecated
-#     integer ProofDays (owner, pro only)
-#     string Backprinting (owner, pro only)
-#     float UnsharpAmount (owner, power & pro only)
-#     float UnsharpRadius (owner, power & pro only)
-#     float UnsharpThreshold (owner, power & pro only)
-#     float UnsharpSigma (owner, power & pro only)
-#     struct Community (owner)
-#       string id
-#    
 #  @author Zac Kleinpeter 
 #  @date 2009-04-28.
 class Smile::Album < Smile::Base
@@ -90,16 +73,12 @@ class Smile::Album < Smile::Base
   class << self
     # Converts the json results from the web service into 
     # Album object to use
-    def from_json( json, session_id )
-      result = JSON.parse( json )
-      result["Albums"].map do |album_upcase|
-        album = upper_hash_to_lower_hash( album_upcase )
-        
+    def from_json( json )
+      json["albums"].map do |album_upper|
+        album = upper_hash_to_lower_hash( album_upper )
         album.merge!( :album_id => album["id"] )
-        
-        a = Smile::Album.new( album )
-        a.session_id = session_id
-        a
+
+        Smile::Album.new( album )
       end
     end
     
@@ -112,23 +91,12 @@ class Smile::Album < Smile::Base
     # @param options [optional, String] :password password for the albums
     # @param options [optional, String] :site_password password for the site
     def find( options={} )
-      params = default_params.merge(
-          :method => 'smugmug.albums.getInfo'
-      )
+      json = web_method_call( { :method => 'smugmug.albums.getInfo' }, options )
       
-      options = Smile::ParamConverter.clean_hash_keys( options )
-      params.merge!( options ) if( options )
-      
-      json = RestClient.post( Smile::Base::BASE, params ).body
-      
-      album_upper = JSON.parse(json)
-    
-      album = upper_hash_to_lower_hash( album_upper['Album'] )
+      album = json['album'] 
       album.merge!( :album_id => album["id"] )
       
-      a = Smile::Album.new( album )
-      a.session_id = session_id
-      a
+      Smile::Album.new( album )
     end
     
     # Update the album from the following params
@@ -196,18 +164,9 @@ class Smile::Album < Smile::Base
     # Community
     # @option options [optional, Fixnum] :community_id ( 0 ) join the group
     def create( title, options )
-      params = default_params.merge(
-          :method => 'smugmug.albums.create',
-          :AlbumID => album_id
-      )
-      options = Smile::ParamConverter.clean_hash_keys( options )
-      params.merge!( options ) if( options )
+      json = web_method_call( { :method => 'smugmug.albums.create', :AlbumID => album_id })
 
-      json = RestClient.post( BASE, params ).body
-      json = JSON.parse( json )
-      raise json["message"] if json["stat"] == 'fail'
-      find( :album_id => json["Album"]["id"], :album_key => json["Album"]["key"] )
-      true
+      self.from_json( json )
     end
   end
 
@@ -276,16 +235,8 @@ class Smile::Album < Smile::Base
   # Community
   # @option options [optional, Fixnum] :community_id join the group
   def update( options )
-    params = default_params.merge(
-        :method => 'smugmug.albums.changeSettings',
-        :AlbumID => album_id
-    )
-    options = Smile::ParamConverter.clean_hash_keys( options )
-    params.merge!( options ) if( options )
-    
-    json = RestClient.post( BASE, params ).body
-    json = JSON.parse( json )
-    raise json["message"] if json["stat"] == 'fail'
+    json = web_method_call( { :method => 'smugmug.albums.changeSettings', :AlbumID => album_id } )
+
     true
   end
   
@@ -297,18 +248,16 @@ class Smile::Album < Smile::Base
   # @option options [optional, string] :password password for the pics
   # @option options [optional, string] :site_password access via site password
   def photos( options=nil )
-    params = default_params.merge(
-        :method => 'smugmug.images.get',
-        :AlbumID => album_id,
-        :AlbumKey => key,
-        :Heavy => 1
+    json = web_method_call(
+        {
+          :method => 'smugmug.images.get',
+          :AlbumID => self.album_id,
+          :AlbumKey => self.key,
+          :Heavy => 1
+        },
+        options
     )
-    options = Smile::ParamConverter.clean_hash_keys( options )
-    params.merge!( options ) if( options )
-    
-    json = RestClient.post( BASE, params ).body
-
-    Smile::Photo.from_json( json, session_id )
+    Smile::Photo.from_json( json )
   end
   
   # Pull stats for an Album for a given Month and Year
@@ -318,23 +267,12 @@ class Smile::Album < Smile::Base
   # @option options [optional, Fixnum] :year (Date.today.year) the year and stuff
   # @option options [optional, 1 or 0] :heavy more details
   def stats( options =nil )
-    params = default_params.merge( 
-      :method => 'smugmug.albums.getStats',
-      :AlbumID => album_id,
-      :month => Date.today.month,
-      :year => Date.today.year
+    json = web_method_call( 
+      { :method => 'smugmug.albums.getStats', :AlbumID => album_id, :month => Date.today.month, :year => Date.today.year },
+      options
     )
-    options = Smile::ParamConverter.clean_hash_keys( options )
-    
-    params.merge!( options ) if( options )
-    
-    json = RestClient.post( Smile::Base::BASE, params ).body
-    
-    json = JSON.parse( json )
-    raise json["message"] if json["stat"] == 'fail'
 
-    stat = upper_hash_to_lower_hash( json['Album'] )
-    OpenStruct.new( stat )
+    OpenStruct.new( json['album'] )
   end
   
   # Add an image or vid to the existing album
@@ -352,9 +290,9 @@ class Smile::Album < Smile::Base
       json = RestClient.put( UPLOAD + "/#{image}", File.read( image ),
         :content_length => File.size( image ),
         :content_md5 => MD5.hexdigest( File.read( image ) ),
-        :x_smug_sessionid => session_id,
+        :x_smug_sessionid => self.session.id,
         :x_smug_version => VERSION,
-        :x_smug_responseType => "JSON",
+        :x_smug_responseType => "Smile::Json",
         :x_smug_albumid => album_id,
         :x_smug_filename => File.basename( image ),
         :x_smug_caption => options[:caption],
@@ -363,35 +301,21 @@ class Smile::Album < Smile::Base
         :x_smug_longitude => options[:longitude],
         :x_smug_altitude => options[:altitude] ).body
       
-      image = JSON.parse( json )
-      if( image && image["Image"] && image["Image"]["id"] )
-        Smile::Photo.find( :image_id => image["Image"]["id"] )
+      image = Smile::Json.parse( json )
+      if( image && image["image"] && image["image"]["id"] )
+        Smile::Photo.find( :image_id => image["image"]["id"] )
       else
-        raise Exception.new( "Failed to upload #{image}" )
+        raise Smile::Exception.new( "Failed to upload #{image}" )
       end
     else
-      raise Exception.new( "Cannot find file #{image}." )
+      raise Smile::Exception.new( "Cannot find file #{image}." )
     end
   end
   
   # Want to get rid of that album?  Call this guy and see what gets removed!
   def delete!
-    params = default_params.merge( 
-      :method => 'smugmug.albums.delete',
-      :AlbumID => album_id
-    )
-    
-    options = Smile::ParamConverter.clean_hash_keys( options )
-    
-    params.merge!( options ) if( options )
-    
-    json = RestClient.post( Smile::Base::BASE, params ).body
-    
-    json = JSON.parse( json )
-    raise json["message"] if json["stat"] == 'fail'
-    
-    album_id = nil
-    album_key = nil
+    json = web_method_call( { :method => 'smugmug.albums.delete', :AlbumID => album_id })
+
     nil
   end
   
@@ -400,22 +324,21 @@ class Smile::Album < Smile::Base
   # @option options [String] :by valid values: FileName, Caption, DateTime
   # @option options [String] :direction valid values: ASC, DESC
   def resort!( options =nil )
-    params = default_params.merge( 
-      :method => 'smugmug.albums.reSort',
-      :AlbumID => album_id
-    )
-    
-    json = RestClient.post( Smile::Base::BASE, params ).body
-    
-    json = JSON.parse( json )
-    raise json["message"] if json["stat"] == 'fail'
-    
-    album_id = nil
-    album_key = nil
+    json = web_method_call( { :method => 'smugmug.albums.reSort', :AlbumID => album_id }, options)
+
     nil
   end
   
+  def reload!
+    replace_with = Smile::Album.find(self.album_id, self.album_key )
+#    self = replace_with
+  end
+
   def category
     ['category']
   end
+
+  def subcategory
+    ['subcategory']
+  end
 end

data/lib/smile/base.rb

@@ -7,54 +7,19 @@
 # 
 module Smile
   class Base < OpenStruct
-    BASE = 'http://api.smugmug.com/hack/json/1.2.0/'
-    BASE_SECURE = 'https://api.smugmug.com/hack/json/1.2.0/'
-    API = 'HSoqGCJ8ilF42BeThMGDZqqqOgj1eXqN'
-    UPLOAD = "http://upload.smugmug.com/"
+    include Smile::Common
 
-    VERSION = '1.2.0'
-    
     class << self
-      attr_accessor :session_id
-      # This will be included in every request once you have logged in
-      def default_params
-        base = { :APIKey => API }
-        if( session_id )
-          base.merge!( :SessionID => session_id )
-        end
-        base
-      end
-      
-      def set_session
-        if( session_id.nil? )
-          smug = Smug.new
-          smug.auth_anonymously
-          self.session_id = smug.session_id
-        end
+      include Smile::Common
+
+      def configure
+        yield( session ) 
       end
-      
-      def upper_hash_to_lower_hash( upper )
-        if( Hash === upper )
-          lower ={}
-          upper.each_pair do |key, value|
-            lower[key.downcase] = upper_hash_to_lower_hash( value )
-          end
-          lower
-        else
-          upper
-        end
+
+      def clear_config!
+        session.clear_config!
       end
-      
-    end
-    
-    attr_accessor :session_id
-    def default_params
-      self.class.session_id = self.session_id
-      self.class.default_params
     end
 
-    def upper_hash_to_lower_hash( hash )
-      self.class.upper_hash_to_lower_hash( hash )
-    end
   end
-end
+end

data/lib/smile/common.rb

@@ -0,0 +1,56 @@
+module Smile
+  module Common
+    BASE = 'http://api.smugmug.com/hack/json/1.2.0/'
+    BASE_SECURE = 'https://api.smugmug.com/hack/json/1.2.0/'
+    UPLOAD = "http://upload.smugmug.com/"
+
+    VERSION = '1.2.0'
+
+    def session
+      @session ||= Session.instance
+    end
+
+    # This will be included in every request once you have logged in
+    def default_params
+      @params ||= { :APIKey => session.api_key }
+      @params.merge!( :SessionID => session.id ) if( session.id )
+      @params
+    end
+
+    # This is the base work that will need to be done on ALL 
+    # web calls.  Given a set of web options and other params
+    # call the web service and convert it to json
+    def web_method_call( web_options, options = {} )
+      params = default_params.merge( web_options )
+      options = Smile::ParamConverter.clean_hash_keys( options )
+      params.merge!( options ) if( options )
+
+      logger.info( params.inspect )
+
+      json = RestClient.post( BASE, params ).body
+      upper_hash_to_lower_hash(Smile::Json.parse( json ) )
+    end
+
+    # This converts a hash that has mixed case
+    # into all lower case
+    def upper_hash_to_lower_hash( upper )
+      if( Hash === upper )
+        lower ={}
+        upper.each_pair do |key, value|
+          lower[key.downcase] = upper_hash_to_lower_hash( value )
+        end
+        lower
+      else
+        upper
+      end
+    end
+
+    def logger
+      session.logger
+    end
+
+    def logger_on?
+      session.logger_on?
+    end
+  end
+end

data/lib/smile/exception.rb

@@ -0,0 +1,12 @@
+module Smile 
+  class Exception < StandardError
+    def initialize( message =nil )
+      Smile::Base.logger.error( message )
+      super( message )
+    end
+  end
+
+  exceptions = %w[ InvalidLogin ]
+
+  exceptions.each { |ex| const_set( ex, Class.new(Smile::Exception) ) }
+end

data/lib/smile/json.rb

@@ -0,0 +1,24 @@
+module Smile
+  class Json 
+  
+    class << self
+      def parse( text )
+        @result = JSON.parse(text) # This is the default JSON parse
+        raise_exception! if has_error?
+        @result  
+      end
+
+      def has_error?
+        @result["stat"] == 'fail'
+      end
+
+      def error_message
+        @result["message"] if has_error?
+      end
+
+      def raise_exception!
+        raise Smile::Exception.new( error_message )
+      end
+    end
+  end
+end

data/lib/smile/param_converter.rb

@@ -4,101 +4,27 @@ module Smile::ParamConverter
   def convert( param, value=nil )
     key = nil
     key = case param.to_s.downcase.to_sym
-      when :popular_category
-        :popularCategory
-      when :geo_all 
-        :geoAll
-      when :geo_keyword 
-        :geoKeyword
-      when :geo_search 
-        :geoSearch
-      when :geo_community
-        :geoCommunity 
-      when :open_search_keyword
-        :openSearchKeyword
-      when :user_keyword 
-        :userkeyword
-      when :nickname_recent 
-        :nicknameRecent
-      when :nickname_popular 
-        :nicknamePopular
-      when :user_comments 
-        :userComments
-      when :geo_user 
-        :geoUser
-      when :geo_album 
-        :geoAlbum
+      when :popular_category, :geo_all, :geo_keyword,
+        :geo_search, :geo_community, :open_search_keyword, :user_keyword,
+        :nickname_recent, :nickname_popular, :user_comments, :geo_user,
+        :geo_album
+        first_letter_downcase( param.to_s.classify ).to_sym
       when :size
         value = value.titlecase
         :Size
-      when :image_count
-        :ImageCount
       when :data, :type, :description, :keywords, :geography, :position, :header,
         :clean, :filenames, :password, :public, :external, :protected, :watermarking,
         :larges, :originals, :comments, :share, :printable, :backprinting
         param.to_s.upcase.to_sym
-      when :image_id
-        :ImageID
-      when :image_key
-        :ImageKey
-      when :image_count
-        :ImageCount
-      when :nickname, :nick_name
-        :NickName
-      when :category_id
-        :CategoryID
-      when :sub_categroy_id
-        :SubCategoryID
-      when :album_template_id
-        :AlbumTemplateID
-      when :highlight_id
-        :HighlightID
+      when :image_id, :image_key, :image_count, :nick_name, :category_id,
+        :sub_category_id, :album_template_id, :highlight_id, :square_thumbs,
+        :template_id, :sort_method, :sort_direction, :password_hint, :word_searchable,
+        :smug_searchable, :watermark_id, :hide_owner, :x_larges, :x2_larges, :x3_larges,
+        :can_rank, :friend_edit, :family_edit, :color_correction, :default_color, :proof_days,
+        :unsharp_amount, :unsharp_radius, :unsharp_sigma, :community_id
+        param.to_s.classify.to_sym
       when :exif
         :EXIF
-      when :square_thumbs
-        :Square_Thumbs
-      when :tempate_id
-        :TemplateID
-      when :sort_method
-        :SortMethod
-      when :sort_direction
-        :SortDirection
-      when :password_hint
-        :PasswordHint
-      when :word_searchable
-        :WordSearchable
-      when :smug_searchable
-        :SmugSearchable
-      when :watermark_id
-        :WatermarkID
-      when :hide_owner
-        :HideOwner
-      when :x_larges, :xlarges
-        :XLarges
-      when :x2_larges, :x2larges
-        :X2Larges
-      when :x3_larges, :x3larges
-        :X3Larges
-      when :can_rank
-        :CanRank
-      when :friend_edit
-        :FriendEdit
-      when :family_edit
-        :FamilyEdit
-      when :color_correction
-        :ColorCorrection
-      when :default_color
-        :DefaultColor
-      when :proof_days
-        :ProofDays
-      when :unsharp_amount
-        :UnsharpAmount
-      when :unsharp_radius
-        :UnsharpRadius
-      when :unsharp_sigma
-        :UnsharpSigma
-      when :community_id
-        :CommunityID
       else
         key = param
     end
@@ -113,5 +39,9 @@ module Smile::ParamConverter
     end if( hash_to_clean )
     cleaned_hash
   end
-  
+ 
+  def first_letter_downcase( stuff )
+    stuff.to_s.gsub( /^(\w)/, $1.downcase )
+  end
+
 end

data/lib/smile/photo.rb

@@ -7,19 +7,15 @@ class Smile::Photo < Smile::Base
   
   class << self
     # Convert the given xml into photo objects to play with
-    def from_json( json, session_id )
-      result = JSON.parse( json )
-      
-      result["Images"].map do |image_upper|
+    def from_json( json )
+      json["images"].map do |image_upper|
         image = upper_hash_to_lower_hash( image_upper )
         image.merge!( :image_id => image["id"] )
         image.merge!( :album_key => image["album"]["key"] )
         image.merge!( :album_id => image["album"]["id"] )
         image.delete( 'album' )
-      
-        p = Smile::Photo.new( image )
-        p.session_id = session_id
-        p
+
+        Smile::Photo.new( image )
       end
     end
     
@@ -31,26 +27,17 @@ class Smile::Photo < Smile::Base
     # @option options [optional, String] :site_password password word for the site
     # @option options [optional, String] :image_key image key maybe?
     def find( options={} )
-      set_session if( session_id.nil? )
-      options = Smile::ParamConverter.clean_hash_keys( options )
-      
-      params = default_params.merge(
-          :method => 'smugmug.images.getInfo'
+      image = web_method_call(
+          { :method => 'smugmug.images.getInfo' },
+          options
       )
       
-      params.merge!( options ) if( options )
-      json = RestClient.post( Smile::Base::BASE, params ).body
-      image_upper = JSON.parse( json )
-      image = upper_hash_to_lower_hash( image_upper['Image'] )
-      
       image.merge!( :image_id => image["id"] )
       image.merge!( :album_key => image["album"]["key"] )
       image.merge!( :album_id => image["album"]["id"] )
       image.delete( 'album' )
       
-      p = Smile::Photo.new( image )
-      p.session_id = session_id
-      p
+      Smile::Photo.new( image )
     end
   end
   
@@ -97,19 +84,11 @@ class Smile::Photo < Smile::Base
   # @option options [String] :password a password field
   # @option options [String] :site_password site password field
   def details( options =nil )
-    params = default_params.merge(
-      :method => "smugmug.images.getEXIF",
-      :ImageID => self.image_id,
-      :ImageKey => self.key
+    image = web_method_call(
+      { :method => "smugmug.images.getEXIF", :ImageID => self.image_id, :ImageKey => self.key },
+      options
     )
     
-    params.merge!( options ) if( options )
-    json = RestClient.post( Smile::Base::BASE, params ).body
-    
-    json = JSON.parse( json )
-    raise json["message"] if json["stat"] == 'fail'
-      
-    image = upper_hash_to_lower_hash( json['Image'] )
     image.merge!( :image_id => image["id"] )
     
     OpenStruct.new( image )
@@ -156,19 +135,11 @@ class Smile::Photo < Smile::Base
   # integer "id"
   # String "Key"
   def info( options =nil )
-    params = default_params.merge(
-      :method => "smugmug.images.getInfo",
-      :ImageID => self.image_id,
-      :ImageKey => self.key
+    image = web_method_call(
+      { :method => "smugmug.images.getInfo", :ImageID => self.image_id, :ImageKey => self.key },
+      options
     )
-    
-    params.merge!( options ) if( options )
-    json = RestClient.post( Smile::Base::BASE, params ).body
-    
-    json = JSON.parse( json )
-    raise json["message"] if json["stat"] == 'fail'
       
-    image = upper_hash_to_lower_hash( json['Image'] )
     image.merge!( :image_id => image["id"] )
     
     OpenStruct.new( image )  
@@ -207,25 +178,17 @@ class Smile::Photo < Smile::Base
   # String "X3LargeURL" (if available)
   # String "OriginalURL" (if available)
   def urls( options =nil )
-    params = default_params.merge(
-      :method => "smugmug.images.getURLs",
-      :ImageID => self.image_id,
-      :ImageKey => self.key
+    image = web_method_call(
+      { :method => "smugmug.images.getURLs", :ImageID => self.image_id, :ImageKey => self.key },
+      options
     )
-    
-    params.merge!( options ) if( options )
-    json = RestClient.post( Smile::Base::BASE, params ).body
-    
-    json = JSON.parse( json )
-    raise json["message"] if json["stat"] == 'fail'
       
-    image = upper_hash_to_lower_hash( json['Image'] )
     image.merge!( :image_id => image["id"] )
     
     OpenStruct.new( image )  
   end
   
   def album
-    Smile::Album.find( :AlbumID => album_id, :AlbumKey => album_key )
+    Smile::Album.find( :AlbumID => self.album_id, :AlbumKey => self.album_key )
   end
 end

data/lib/smile/session.rb

@@ -0,0 +1,37 @@
+module Smile
+  class Session
+    include Singleton
+    API = 'HSoqGCJ8ilF42BeThMGDZqqqOgj1eXqN'
+
+    attr_accessor :id, :api_key, :logger_on
+    attr_reader :log
+
+    def has_id?
+      @id.nil?
+    end
+
+    def api_key
+      @api_key || API
+    end
+
+    def logger
+      if( logger_on? )
+        @log ||= Logger.new( STDOUT )
+        RestClient.log ||= @log  
+        @log
+      else
+        @blank ||= Logger.new nil
+        RestClient.log ||= @blank  
+        @blank
+      end
+    end
+
+    def logger_on?
+      @logger_on
+    end
+
+    def clear_config!
+      @api_key, @log, @logger_on = nil,nil,nil
+    end
+  end
+end

data/lib/smile/smug.rb

@@ -15,19 +15,12 @@ module Smile
     #
     # @return [Smile::SmugMug.new] An Smug object that has been authenticated
     def auth( email, pass )
-     params = default_params.merge(
-        :method => 'smugmug.login.withPassword',
-        :EmailAddress => email,
-        :Password => pass
+     json = web_method_call(
+        { :method => 'smugmug.login.withPassword', :EmailAddress => email, :Password => pass }
       )
 
-      json = RestClient.post( BASE, params ).body
-      result = JSON.parse( json )
-      
-      self.session_id = result["Login"]["Session"]["id"]
-      result
-    rescue NoMethodError => e
-      nil
+      self.session.id = json["login"]["session"]["id"]
+      json
     end
 
     # Login to SmugMug using an anonymously account
@@ -35,25 +28,15 @@ module Smile
     #
     # @return [Smile::SmugMug.new] An Smug object that has been authenticated
     def auth_anonymously
-      params = default_params.merge(
-        :method => 'smugmug.login.anonymously'
-      )
+      json = web_method_call( { :method => 'smugmug.login.anonymously' } )
 
-      json = RestClient.post( BASE, params ).body
-      result = JSON.parse( json )
-      self.session_id = result["Login"]["Session"]["id"]
-      result
-    rescue NoMethodError => e
-      nil
+      self.session.id = json["login"]["session"]["id"]
+      json 
     end
 
     # Close the session
     def logout
-      params = default_params.merge(
-        :method => 'smugmug.logout'
-      )
-
-      RestClient.post( BASE, params ).body
+      web_method_call( { :method => 'smugmug.logout' } )
     end
 
     
@@ -72,18 +55,12 @@ module Smile
     # 
     # @see Smug::Album#new For more information about heavy ( true and false ) responces
     def albums( options=nil )
-      params = default_params.merge( 
-        :method => 'smugmug.albums.get',
-        :heavy => 1
+      json = web_method_call( 
+        { :method => 'smugmug.albums.get', :heavy => 1 },
+        options
       )      
 
-      options = Smile::ParamConverter.clean_hash_keys( options )
-      params = params.merge( options ) if( options )
-      json = RestClient.post( BASE, params ).body
-
-      Smile::Album.from_json( json, session_id )
-    rescue
-      nil
+      Smile::Album.from_json( json )
     end
   end
 end

data/lib/smile.rb

@@ -1,11 +1,15 @@
 require 'active_support'
 require 'restclient'
 require 'ostruct'
-require 'lib/smile/base'
-require 'lib/smile/smug'
-require 'lib/smile/album'
-require 'lib/smile/photo'
-require 'lib/smile/param_converter'
+require File.dirname(__FILE__) + '/smile/session'
+require File.dirname(__FILE__) + '/smile/common'
+require File.dirname(__FILE__) + '/smile/base'
+require File.dirname(__FILE__) + '/smile/smug'
+require File.dirname(__FILE__) + '/smile/album'
+require File.dirname(__FILE__) + '/smile/photo'
+require File.dirname(__FILE__) + '/smile/param_converter'
+require File.dirname(__FILE__) + '/smile/exception'
+require File.dirname(__FILE__) + '/smile/json'
 require 'cgi'
 require 'rss'
 require 'json'

data/smile.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{smile}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["cajun"]
-  s.date = %q{2010-04-17}
+  s.date = %q{2010-05-13}
   s.default_executable = %q{smile}
   s.email = %q{zac@kleinpeter.org}
   s.executables = ["smile"]
@@ -23,12 +23,15 @@ Gem::Specification.new do |s|
      "README.rdoc",
      "Rakefile",
      "VERSION.yml",
-     "config/metric_fu_config.rb",
      "lib/smile.rb",
      "lib/smile/album.rb",
      "lib/smile/base.rb",
+     "lib/smile/common.rb",
+     "lib/smile/exception.rb",
+     "lib/smile/json.rb",
      "lib/smile/param_converter.rb",
      "lib/smile/photo.rb",
+     "lib/smile/session.rb",
      "lib/smile/smug.rb",
      "smile.gemspec",
      "test/smile_test.rb",

data/test/smile_test.rb

@@ -1,63 +1,82 @@
 require File.dirname(__FILE__) + '/test_helper'
 
-class SmileTest < Test::Unit::TestCase
-  def setup
+Shindo.tests 'checking all the cool things smile can do'  do
+  extend RR::Adapters::RRMethods
+
+  before do
+    # this resets the config to the base state before every test
+    Smile::Base.clear_config!
+    Smile::Base.configure do |config|
+      # config.logger_on = true
+    end
+
     @smug = Smile::Smug.new
     @smug.auth_anonymously
   end
-  
-  def test_auth
-    assert_not_nil( @smug.auth_anonymously )
-  end
-  
-  def test_have_albums
-    assert_nothing_raised(Exception) do
-      assert_not_nil( @smug.albums( :nick_name => 'kleinpeter' ) )
+
+  tests 'security checks', ['security'] do
+    test( 'testing basic auth anonymously' ) { @smug.auth_anonymously }
+
+    test 'InvalidLogin will get raised on foo bar login' do
+      all_good = false
+      begin
+        Smile.auth( 'foo', 'and mo bar' )
+      rescue Smile::Exception => ex
+        all_good = true
+      end
+
+      all_good
     end
   end
-  
-  def test_have_photos
-    assert_nothing_raised(Exception) do
+
+  tests 'album and photo checks' do
+    test( 'checking to see if we have some albums', ['album']) do 
+      @smug.albums( :nick_name => 'kleinpeter' ) 
+    end
+    
+    test( 'we can reload albums from the site', ['album']) 
+    
+    test 'checking to see if we have photos in the albums', ['album'] do 
       album = @smug.albums( :nick_name => 'kleinpeter' ).first
-      assert_not_nil( album.photos )
+      !album.photos.empty?
     end
-  end
-  
-  def test_photo_has_album
-    assert_nothing_raised(Exception) do
+
+    test 'a photo is connected to its album', ['photo'] do
       album = @smug.albums( :nick_name => 'kleinpeter' ).first
       photo = album.photos.first
-      assert_equal( album.album_id, photo.album.album_id )
-      assert_equal( album.key, photo.album.key )
+      album.album_id == photo.album.album_id && 
+      album.key == photo.album.key 
     end
   end
   
-  def test_photo_has_album_has_photo
-    assert_nothing_raised(Exception) do
-      album = @smug.albums( :nick_name => 'kleinpeter' ).first
-      photo = album.photos.first
-      alt_photo = photo.album.photos.first
-      
-      assert_equal( photo.image_id, alt_photo.image_id )
+  tests 'confirm configuration settings', ['config'] do
+    test 'there is a default api key' do
+      Smile::Base.session.api_key
+    end
+
+    test 'we can set the api key in the config' do
+      Smile::Base.configure do |config|
+        config.api_key = 'foo'
+      end
+
+      Smile::Base.session.api_key
     end
   end
-  
-  # NOTE have to be logged in to test this one
-  # def test_album_stats
-  #   assert_nothing_raised(Exception) do
-  #     album = @smug.albums( :nick_name => 'kleinpeter' ).first
-  #     assert_not_nil( album.stats )
-  #   end
-  # end
-  
-  def test_photo_extras
-    assert_nothing_raised(Exception) do
-      album = @smug.albums( :nick_name => 'kleinpeter' ).first
-      photo = album.photos.first
-      
-      assert_not_nil( photo.details )
-      assert_not_nil( photo.info )
-      assert_not_nil( photo.urls )
+
+  tests 'there is a logger and it does stuff' do 
+    test 'the logger is off by default', ['log'] do
+      Smile::Base.clear_config!
+      !Smile::Base.logger_on?
+    end
+  end
+
+  tests 'looking now at the exception classes', ['exceptions'] do
+    test 'exceptions should log errors' do
+      @@error_got_called = false
+      mock(Smile::Base.logger).error( 'foo' ) { @@error_got_called = true }
+      Smile::Exception.new( 'foo' )
+      @@error_got_called
     end
   end
 end
+

data/test/test_helper.rb

@@ -1,10 +1,8 @@
 require 'rubygems'
-require 'test/unit'
-require 'ruby-debug' 
+require 'shindo'
+require 'rr'
+
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'smile'
-
-class Test::Unit::TestCase
-end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - cajun
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-17 00:00:00 -05:00
+date: 2010-05-13 00:00:00 -05:00
 default_executable: smile
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -56,12 +56,15 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION.yml
-- config/metric_fu_config.rb
 - lib/smile.rb
 - lib/smile/album.rb
 - lib/smile/base.rb
+- lib/smile/common.rb
+- lib/smile/exception.rb
+- lib/smile/json.rb
 - lib/smile/param_converter.rb
 - lib/smile/photo.rb
+- lib/smile/session.rb
 - lib/smile/smug.rb
 - smile.gemspec
 - test/smile_test.rb

data/config/metric_fu_config.rb

@@ -1,31 +0,0 @@
-MetricFu::Configuration.run do |config|
-  #define which metrics you want to use
-  config.metrics  = [:churn, :saikuro, :flog, :flay, :reek, :roodi, :rcov]
-  config.graphs   = [:flog, :flay, :reek, :roodi, :rcov]
-  config.flay     = { :dirs_to_flay => ['lib'],
-    :minimum_score => 100  } 
-  config.flog     = { :dirs_to_flog => ['lib']  }
-  config.reek     = { :dirs_to_reek => ['lib']  }
-  config.roodi    = { :dirs_to_roodi => ['lib'] }
-  config.saikuro  = { :output_directory => 'scratch_directory/saikuro', 
-    :input_directory => ['lib'],
-    :cyclo => "",
-    :filter_cyclo => "0",
-    :warn_cyclo => "5",
-    :error_cyclo => "7",
-    :formater => "text"} #this needs to be set to "text"
-  config.churn    = { :start_date => "1 year ago", :minimum_churn_count => 10}
-  config.rcov     = { :environment => 'test',
-    :test_files => ['test/*_test.rb'],
-      :rcov_opts => ["--sort coverage", 
-        "--no-html", 
-        "--text-coverage",
-        "--profile",
-        "--exclude /gems/,/Library/,spec"]}
-  config.graph_engine = :bluff
-end
-
-namespace :metrics do
-TEST_PATHS_FOR_RCOV = ['test/*_test.rb']
-end
-