digitalpardoe-rflickr 1.1.4 → 2.0.0.pre.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7596bae6878e18dab1003f43bf3967c325e16a73
+  data.tar.gz: e29c316402a4b7f1ba1501521dbda6df2afbe98e
+SHA512:
+  metadata.gz: 2b0dd68fa6db8dba33ae5cfdf717b243ad90d1317d77117de647952b8e39f29f5134a2278feb19ab81f7a43e178b7891176dad15ac2acc9fb78507419323acd7
+  data.tar.gz: 83e1fe9d4fe531d710458d73e5b1230fa7df309c54e377a53571992070a592ae4a6feeedbc9a4bb8a9d4a0d31f4b3c89b06351287fd215b9afe6ffa341e7bdda

data/.autotest

@@ -0,0 +1,5 @@
+require 'autotest/bundler'
+
+Autotest.add_hook :initialize do |at|
+  %w{.git coverage}.each { |exception| at.add_exception(exception) }
+end

data/.document

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

data/Gemfile

@@ -1,9 +1,9 @@
 source "http://rubygems.org"
 
-gem "mime-types", ">= 0"
+gem "json", "~> 1.8.0"
 
 group :development do
-  gem "rdoc", ">= 0"
-  gem "bundler", ">= 0"
-  gem "jeweler", ">= 0"
-end
+  gem "rspec", ">= 0"
+  gem "jeweler", "~> 1.8.4"
+  gem "ZenTest", ">= 0"
+end

data/README.md

@@ -0,0 +1,40 @@
+# rFlickr
+
+**Note**: This gem has only been tested on Ruby 2.0 (but should work with 1.9).
+
+Before you start using this gem you'll need a Flickr API key from [http://www.flickr.com/services/api/misc.api_keys.html](http://www.flickr.com/services/api/misc.api_keys.html).
+
+## Using the Gem
+
+Add:
+
+    gem 'digitalpardoe-rflickr', '~> 2.0.pre.1'
+
+In your Gemfile then using the gem should be as simple as:
+
+    require 'flickr'
+
+After requiring the gem create an instance of it using your API details (instructions on how to get an auth token (optional) for authenticated requests below):
+
+    flickr = Flickr.new( API_KEY, SHARED_SECRET, AUTH_TOKEN )
+
+The gem will automatically construct queries to the Flickr API (returning JSON results) from method names, similar to the way ActiveRecord finders work, for example, to make an authenticated query to get all the members of a group you could call:
+
+    flickr.flickr_groups_members_getList( args: { group_id: @group_id, membertypes: [2] }, auth: true )
+
+No checking happens before the request is sent so ensure you've checked the [Flickr API](http://www.flickr.com/services/api/) for the required parameters if you run in to problems.
+
+If the Flickr method requires a `POST` you can pass `get: false` in the method hash.
+
+## Getting an Auth Token
+
+First you'll need an IRB console with rFlickr available so you can `require 'flickr'` then perform the following steps:
+
+    >> flickr = Flickr.new(API_KEY, SHARED_SECRET)
+    >> flickr.api.login_link
+    
+Navigate to the URL provided and authorise the application.
+
+    >> flickr.auth.get_token
+    
+Store the token received in the response, this is your auth token, you can either use it when you initialise a `Flickr` object or add it at a later point using `flickr.auth_token(AUTH_TOKEN)`.

data/Rakefile

@@ -13,30 +13,26 @@ require 'rake'
 
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
-		gem.name = "digitalpardoe-rflickr"
-		gem.summary = "rFlickr is a Ruby interface to the Flickr API"
-		gem.email = "contact@digitalpardoe.co.uk"
-		gem.homepage = "http://github.com/digitalpardoe/rflickr"
-		gem.authors = ["digital:pardoe"]
-		gem.description = "rFlickr is a clone of the original RubyForge based rflickr, a Ruby implementation of the Flickr API. It includes a faithful albeit old reproduction of the published API."
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "digitalpardoe-rflickr"
+  gem.homepage = "http://github.com/digitalpardoe/rflickr"
+  gem.summary = "rFlickr is a Ruby interface to the Flickr API"
+  gem.description = "rFlickr is a clone of the original RubyForge based rflickr, a Ruby implementation of the Flickr API. It includes a faithful albeit old reproduction of the published API."
+  gem.email = "contact@digitalpardoe.co.uk"
+  gem.authors = ["Alex Pardoe"]
+  # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+	spec.pattern = 'spec/**/*_spec.rb'
 end
 
-task :default => :test
-
-require 'rdoc/task'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "digitalpardoe-rflickr #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+	spec.pattern = 'spec/**/*_spec.rb'
+	spec.rcov = true
+	spec.rcov_opts = ['--exclude', 'spec,.*/.gem']
 end
+
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+2.0.0.pre.1

data/digitalpardoe-rflickr.gemspec

@@ -5,69 +5,66 @@
 
 Gem::Specification.new do |s|
   s.name = "digitalpardoe-rflickr"
-  s.version = "1.1.4"
+  s.version = "2.0.0.pre.1"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["digital:pardoe"]
-  s.date = "2013-08-09"
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alex Pardoe"]
+  s.date = "2013-08-12"
   s.description = "rFlickr is a clone of the original RubyForge based rflickr, a Ruby implementation of the Flickr API. It includes a faithful albeit old reproduction of the published API."
   s.email = "contact@digitalpardoe.co.uk"
   s.extra_rdoc_files = [
-    "LICENSE",
-    "README.markdown"
+    "README.md"
   ]
   s.files = [
+    ".autotest",
+    ".document",
+    ".rspec",
     "Gemfile",
-    "LICENSE",
-    "README.markdown",
+    "README.md",
     "Rakefile",
-    "VERSION.yml",
+    "VERSION",
     "digitalpardoe-rflickr.gemspec",
     "lib/flickr.rb",
-    "lib/flickr/auth.rb",
-    "lib/flickr/base.rb",
-    "lib/flickr/blogs.rb",
-    "lib/flickr/contacts.rb",
-    "lib/flickr/favorites.rb",
-    "lib/flickr/groups.rb",
-    "lib/flickr/interestingness.rb",
-    "lib/flickr/licenses.rb",
-    "lib/flickr/notes.rb",
-    "lib/flickr/people.rb",
-    "lib/flickr/photos.rb",
-    "lib/flickr/photosets.rb",
-    "lib/flickr/pools.rb",
-    "lib/flickr/reflection.rb",
-    "lib/flickr/tags.rb",
-    "lib/flickr/transform.rb",
-    "lib/flickr/upload.rb",
-    "lib/flickr/urls.rb",
-    "test/test_suite.rb"
+    "lib/flickr/api.rb",
+    "lib/flickr/interaction/flickr_api_request.rb",
+    "lib/flickr/interaction/request.rb",
+    "spec/api/activity_spec.rb",
+    "spec/api/api_spec.rb",
+    "spec/api/auth_spec.rb",
+    "spec/api/blogs_spec.rb",
+    "spec/api/collections_spec.rb",
+    "spec/api/commons_spec.rb",
+    "spec/api/contacts_spec.rb",
+    "spec/api/favorites_spec.rb",
+    "spec/api/groups/members_spec.rb",
+    "spec/config/api.example.yml",
+    "spec/flickr_spec.rb",
+    "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/digitalpardoe/rflickr"
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.25"
+  s.rubygems_version = "2.0.3"
   s.summary = "rFlickr is a Ruby interface to the Flickr API"
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<mime-types>, [">= 0"])
-      s.add_development_dependency(%q<rdoc>, [">= 0"])
-      s.add_development_dependency(%q<bundler>, [">= 0"])
-      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_runtime_dependency(%q<json>, ["~> 1.8.0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_development_dependency(%q<ZenTest>, [">= 0"])
     else
-      s.add_dependency(%q<mime-types>, [">= 0"])
-      s.add_dependency(%q<rdoc>, [">= 0"])
-      s.add_dependency(%q<bundler>, [">= 0"])
-      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<json>, ["~> 1.8.0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_dependency(%q<ZenTest>, [">= 0"])
     end
   else
-    s.add_dependency(%q<mime-types>, [">= 0"])
-    s.add_dependency(%q<rdoc>, [">= 0"])
-    s.add_dependency(%q<bundler>, [">= 0"])
-    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<json>, ["~> 1.8.0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+    s.add_dependency(%q<ZenTest>, [">= 0"])
   end
 end
 

data/lib/flickr.rb

@@ -1,38 +1,45 @@
-# rFlickr: A Ruby based Flickr API implementation.
-# Copyright (C) 2009, Alex Pardoe (digital:pardoe)
-#
-# Derrived from work by Trevor Schroeder, see here:
-# http://rubyforge.org/projects/rflickr/.
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+Dir[File.dirname(__FILE__) + "/flickr/**/*.rb"].each { |file| require file }
 
-require 'flickr/auth'
-require 'flickr/base'
-require 'flickr/blogs'
-require 'flickr/contacts'
-require 'flickr/favorites'
-require 'flickr/groups'
-require 'flickr/licenses'
-require 'flickr/notes'
-require 'flickr/people'
-require 'flickr/photos'
-require 'flickr/photosets'
-require 'flickr/pools'
-require 'flickr/reflection'
-require 'flickr/transform'
-require 'flickr/upload'
-require 'flickr/urls'
-require 'flickr/tags'
-require 'flickr/interestingness'
+class Flickr
+	def initialize(api_key, shared_secret, auth_token=nil)
+		@tokens = Flickr::Tokens.new(api_key, shared_secret, auth_token)
+		@api_request = FlickrApiRequest.new(@tokens)
+	end
+
+	def auth_token(auth_token)
+		@tokens.auth_token = auth_token
+		self
+	end
+
+	class Tokens
+		attr_reader :api_key, :shared_secret
+		attr_accessor :auth_token
+
+		def initialize(api_key, shared_secret, auth_token)
+			@api_key = api_key
+			@shared_secret = shared_secret
+			@auth_token = auth_token
+		end
+	end
+
+	def api
+		@api ||= Api.new(@api_request, self)
+	end
+
+  def method_missing(method, *arguments, &block)
+    if method.to_s =~ /^flickr_[\w]+/
+      self.class.send :define_method, method do |*arguments|
+        if (arguments = arguments.flatten) != []
+          args = arguments[0][:args]
+          auth = arguments[0][:auth]
+          get = arguments[0][:get]
+        end
+
+        @api_request.call("#{method.to_s.gsub('_', '.')}", args || {}, (auth == nil ? false : auth), (get == nil ? true : get))
+      end
+      self.send(method, arguments)
+    else
+      super
+    end
+  end
+end

data/lib/flickr/api.rb

@@ -0,0 +1,26 @@
+require 'flickr/interaction/request'
+
+class Api
+	attr_accessor :frob
+  
+	def initialize(api, parent)
+		@api = api
+    @parent = parent
+	end
+
+	def login_link(perms='read')
+		@frob = @parent.flickr_auth_getFrob['frob']['_content']
+		args = {'api_key' => @api.tokens.api_key, 'perms' => perms, 'frob' => @frob}
+		args = @api.sign_request(args)
+
+		Request.build_url('http://flickr.com/services/auth/', args)
+	end
+
+	def get_token(frob=@frob)
+		if frob
+			@parent.flickr_auth_getToken(args: { frob: frob })
+		else
+			raise ArgumentError, "missing 'frob' argument, perhaps you need to call 'login_link' first"
+		end
+	end
+end

data/lib/flickr/interaction/flickr_api_request.rb

@@ -0,0 +1,75 @@
+require 'rubygems'
+require 'json'
+require 'digest'
+
+require 'flickr/interaction/request'
+
+class FlickrApiRequest
+	API_RSP = 'json'
+	API_REQ = 'rest'
+	API_URL = "http://api.flickr.com/services/#{API_REQ}/"
+
+	attr_reader :tokens
+
+	def initialize(tokens)
+		@tokens = tokens
+		@arguments = { 'format' => API_RSP, 'api_key' => @tokens.api_key }
+	end
+
+	def call(method, arguments, authenticated, get)
+		arguments ? arguments = arguments.merge(@arguments) : arguments = @arguments
+
+		arguments = arguments.merge({'method' => method})
+    arguments = objects_to_strings(arguments)
+		arguments = remove_blank_args(arguments)
+
+		if authenticated
+			if !@tokens.auth_token
+				return {'stat' => 'fail'}
+			end
+
+			arguments = arguments.merge({'auth_token' => @tokens.auth_token})
+    end
+    
+    arguments = sign_request(arguments)
+
+		begin
+			JSON.parse strip_function(Request.make(API_URL, arguments.class == Array ? arguments : arguments.to_a, get))
+		rescue JSON::ParserError
+			nil
+		end
+	end
+
+	def sign_request(arguments)
+		arguments = sort_arguments(arguments)
+
+		api_sig = @tokens.shared_secret.clone
+		arguments.each { |item| api_sig << item[0].to_s + item[1].to_s }
+		sig_digest = Digest::MD5.hexdigest(api_sig)
+
+		arguments.insert(0, ['api_sig', sig_digest])
+
+		arguments
+	end
+
+	private
+  def objects_to_strings(arguments)
+    {}.tap do |hash|
+      arguments.each do |key,value|
+        hash[key.to_s] = value.class == Array ? value.join(",") : value
+      end
+    end
+  end
+  
+	def remove_blank_args(arguments)
+		arguments.delete_if { |key,value| value == nil }
+	end
+
+	def sort_arguments(arguments)
+		arguments.sort { |a,b| a[0]<=>b[0] }
+	end
+
+	def strip_function(json_string)
+		json_string.gsub('jsonFlickrApi(', '').gsub(')', '')
+	end
+end

data/lib/flickr/interaction/request.rb

@@ -0,0 +1,37 @@
+require 'net/http'
+require 'uri'
+
+class Request
+    def self.make(url, arguments, get)
+		get ? get(url, arguments) : post(url, arguments)
+	end
+
+	def self.build_url(url, arguments)
+		query_string = '?'
+		arguments.length.times do |i|
+			query_string << arguments[i][0].to_s + '=' + arguments[i][1].to_s + '&'
+		end
+
+		url + query_string.chomp('&')
+	end
+
+	private
+	def self.get(url, arguments)
+		connection.get URI.parse(build_url(url, arguments))
+	end
+
+	def self.post(url, arguments)
+		connection.post_form URI.parse(url), arguments
+	end
+
+	def self.connection
+		if proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
+			proxy = URI.parse(proxy)
+			agent = Net::HTTP.Proxy(proxy.host, proxy.port)
+		else
+			agent = Net::HTTP
+		end
+
+		agent
+	end
+end