soundcloud-auth 0.1.0

data/README.markdown

@@ -0,0 +1,2 @@
+SoundCloudAuth
+===========

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "soundcloud-auth"
+    gemspec.summary = "SoundcloudAuth is a Rails plugin gem that provides Single Sign-On capabilities for Rails applications via SoundCloud."
+    gemspec.description = "SoundcloudAuth is a Rails plugin gem that provides Single Sign-On capabilities for Rails applications via SoundCloud."
+    gemspec.email = "lee@soundcloud.com"
+    gemspec.homepage = "http://github.com/leemartin/soundcloud-auth"
+    gemspec.authors = ["Lee Martin"]
+    gemspec.add_dependency('oauth', '>= 0.3.1')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/app/controllers/sessions_controller.rb

@@ -0,0 +1,61 @@
+class SessionsController < ApplicationController
+  
+  unloadable
+
+  def new
+
+    oauth_callback = request.protocol + request.host_with_port + '/oauth_callback'
+    @request_token = SoundcloudAuth.consumer.get_request_token({:oauth_callback=>oauth_callback})
+    session[:request_token] = @request_token.token
+    session[:request_token_secret] = @request_token.secret
+   
+    url = @request_token.authorize_url
+    url << "&oauth_callback=#{CGI.escape(SoundcloudAuth.oauth_callback)}" if SoundcloudAuth.oauth_callback?      
+    redirect_to url
+      
+  end
+
+  def oauth_callback
+    
+    unless session[:request_token] && session[:request_token_secret] 
+      authentication_failed('No authentication information was found in the session. Please try again.') and return
+    end
+
+    unless params[:oauth_token].blank? || session[:request_token] ==  params[:oauth_token]
+     authentication_failed('Authentication information does not match session information. Please try again.') and return
+    end
+
+    @request_token = OAuth::RequestToken.new(SoundcloudAuth.consumer, session[:request_token], session[:request_token_secret])
+
+    oauth_verifier = params["oauth_verifier"]
+    @access_token = @request_token.get_access_token(:oauth_verifier => oauth_verifier)
+    
+    session[:request_token] = nil
+    session[:request_token_secret] = nil
+    
+    puts @access_token
+
+    #@user = User.identify_or_create_from_access_token(@access_token)
+
+    #session[:user_id] = @user.id
+
+    #cookies[:remember_token] = @user.remember_me
+
+    #authentication_succeeded 
+    
+    rescue Net::HTTPServerException => e
+      case e.message
+        when '401 "Unauthorized"'
+          authentication_failed('This authentication request is no longer valid. Please try again.') and return
+        else
+          authentication_failed('There was a problem trying to authenticate you. Please try again.') and return
+    end 
+    
+  end
+  
+  def destroy
+    logout_keeping_session!
+    redirect_back_or_default('/')
+  end
+  
+end

data/app/models/soundcloud_auth/generic_user.rb

@@ -0,0 +1,119 @@
+module SoundcloudAuth
+  class GenericUser < ActiveRecord::Base
+    
+    attr_protected :soundcloud_id, :remember_token, :remember_token_expires_at
+    
+    SOUNDCLOUD_ATTRIBUTES = [
+      :plan,
+      :avatar_url,
+      :website_title,
+      :permalink,
+      :city,
+      :uri,
+      :country,
+      :username,
+      :discogs_name,
+      :website,
+      :full_name,
+      :followers_count,
+      :description,
+      :permalink_url,
+      :followings_count,
+      :track_count,
+      :myspace_name
+    ]
+    
+    with_options :if => :utilize_default_validations do |v|
+      v.validates_presence_of :soundcloud_id
+      v.validates_uniqueness_of :soundcloud_id, :message => "ID has already been taken."
+      v.validates_uniqueness_of :remember_token, :allow_blank => true
+    end
+    
+    def self.table_name; 'users' end
+
+    def self.new_from_soundcloud_hash(hash)
+
+      raise ArgumentError, 'Invalid hash: must include id.' unless hash.key?('id')
+
+      user = User.new
+      user.soundcloud_id = hash['id'].to_s
+
+      SOUNDCLOUD_ATTRIBUTES.each do |att|
+        user.send("#{att}=", hash[att.to_s]) if user.respond_to?("#{att}=")
+      end
+
+      user
+      
+    end
+
+    def self.from_remember_token(token)
+      first(:conditions => ["remember_token = ? AND remember_token_expires_at > ?", token, Time.now])
+    end
+      
+    def assign_soundcloud_attributes(hash)
+      SOUNDCLOUD_ATTRIBUTES.each do |att|
+        send("#{att}=", hash[att.to_s]) if respond_to?("#{att}=")
+      end
+    end
+
+    def update_soundcloud_attributes(hash)
+      assign_soundcloud_attributes(hash)
+      save
+    end
+    
+    def self.identify_or_create_from_access_token(token, secret=nil)
+      
+      raise ArgumentError, 'Must authenticate with an OAuth::AccessToken or the string access token and secret.' unless (token && secret) || token.is_a?(OAuth::AccessToken)
+      
+      token = OAuth::AccessToken.new(SoundcloudAuth.consumer, token, secret) unless token.is_a?(OAuth::AccessToken)
+      
+      user_info = JSON.parse(token.get(SoundcloudAuth.path_prefix + '/me.json'))
+      
+      if user = User.find_by_soundcloud_id(user_info['id'].to_s)
+        user.assign_soundcloud_attributes(user_info)
+        user.access_token = token.token
+        user.access_secret = token.secret
+        user.save
+        user
+      else
+        User.create_from_soundcloud_hash_and_token(user_info, token) 
+      end
+      
+    end
+
+    def self.create_from_soundcloud_hash_and_token(user_info, access_token)
+      user = User.new_from_soundcloud_hash(user_info)
+      user.access_token = access_token.token
+      user.access_secret = access_token.secret
+      user.save
+      user
+    end
+
+    def utilize_default_validations
+      true
+    end
+
+    def soundcloud
+      # OAuth::AccessToken.new(TwitterAuth.consumer, access_token, access_secret)
+    end
+
+    def remember_me
+      
+      return false unless respond_to?(:remember_token)
+
+      self.remember_token = ActiveSupport::SecureRandom.hex(10)
+      self.remember_token_expires_at = Time.now + SoundcloudAuth.remember_for.days
+      
+      save
+
+      {:value => self.remember_token, :expires => self.remember_token_expires_at}
+      
+    end
+
+    def forget_me
+      self.remember_token = self.remember_token_expires_at = nil
+      self.save
+    end
+    
+  end
+end

data/config/routes.rb

@@ -0,0 +1,6 @@
+ActionController::Routing::Routes.draw do |map|
+  map.login '/login', :controller => 'sessions', :action => 'new'
+  map.logout '/logout', :controller => 'sessions', :action => 'destroy'
+  map.resource :session
+  map.oauth_callback '/oauth_callback', :controller => 'sessions', :action => 'oauth_callback'
+end

data/generators/soundcloud_auth/USAGE

@@ -0,0 +1,10 @@
+SoundcloudAuth Generator
+=====================
+
+The SoundcloudAuth generator allows you to generate the components necessary to implement SoundCloud as a Single Sign-On provider for your site.
+
+To run it, you simply need to call it:
+
+script/generate soundcloud_auth
+
+This will generate the migration necessary for the users table as well as generate a User model that extends the appropriate SoundcloudAuth model template and a config/soundcloud_auth.yml that allows you to set your OAuth consumer key and secret.

data/generators/soundcloud_auth/soundcloud_auth_generator.rb

@@ -0,0 +1,13 @@
+class SoundcloudAuthGenerator < Rails::Generator::Base
+
+  def manifest
+    record do |m|
+      m.class_collisions 'User'
+
+      m.migration_template 'migration.rb', 'db/migrate', :migration_file_name => 'soundcloud_auth_migration'
+      m.template 'user.rb', File.join('app','models','user.rb')
+      m.template 'soundcloud_auth.yml', File.join('config','soundcloud_auth.yml')
+    end
+  end
+
+end

data/generators/soundcloud_auth/templates/migration.rb

@@ -0,0 +1,41 @@
+class SoundcloudAuthMigration < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      
+      t.string :soundcloud_id
+      t.string :username
+      t.string :access_token
+      t.string :access_secret
+
+      t.string :remember_token
+      t.datetime :remember_token_expires_at
+
+      # This information is automatically kept
+      # in-sync at each login of the user. You
+      # may remove any/all of these columns.
+      
+      t.string :plan
+      t.string :avatar_url
+      t.string :website_title
+      t.string :permalink
+      t.string :city
+      t.string :uri
+      t.string :country
+      t.string :discogs_name
+      t.string :website
+      t.string :full_name
+      t.integer :followers_count
+      t.string :description
+      t.string :permalink_url
+      t.integer :followings_count
+      t.integer :track_count
+      t.string :myspace_name
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :users
+  end
+end

data/generators/soundcloud_auth/templates/soundcloud_auth.yml

@@ -0,0 +1,17 @@
+development:
+  key: devkey
+  secret: devsecret
+  base_url: "http://api.soundcloud.com"
+  remember_for: 14 # days
+  oauth_callback: "http://localhost:3000/oauth_callback"
+test:
+  key: testkey
+  secret: testsecret
+  base_url: "http://api.soundcloud.com"
+  remember_for: 14 # days
+  oauth_callback: "http://localhost:3000/oauth_callback"
+production:
+  key: prodkey
+  secret: prodsecret 
+  base_url: "http://api.soundcloud.com"
+  remember_for: 14 # days

data/generators/soundcloud_auth/templates/user.rb

@@ -0,0 +1,5 @@
+class User < SoundcloudAuth::GenericUser
+  # Extend and define your user model as you see fit.
+  # All of the authentication logic is handled by the 
+  # parent SoundcloudAuth::GenericUser class.
+end

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/rails/init'

data/lib/soundcloud_auth.rb

@@ -0,0 +1,51 @@
+module SoundcloudAuth
+  class Error < StandardError; end
+
+  def self.config(environment=RAILS_ENV)
+    @config ||= {}
+    @config[environment] ||= YAML.load(File.open(RAILS_ROOT + '/config/soundcloud_auth.yml').read)[environment]
+  end
+  
+  def self.base_url
+    config['base_url'] || 'http://api.soundcloud.com'    
+  end
+
+  def self.path_prefix
+    URI.parse(base_url).path
+  end
+
+  def self.oauth_callback?
+    config.key?('oauth_callback')
+  end
+
+  def self.oauth_callback
+    config['oauth_callback']
+  end
+
+  def self.remember_for
+    (config['remember_for'] || 14).to_i
+  end
+  
+  def self.consumer
+    
+    options = {
+      :site => TwitterAuth.base_url,
+      :request_token_path => "/oauth/request_token",
+      :access_token_path => "/oauth/access_token",
+      :authorize_path => "/oauth/authorize"
+    }
+    
+    OAuth::Consumer.new(
+      config['key'],
+      config['secret'],
+      options
+    )
+    
+  end
+  
+=end
+  
+end
+
+require 'soundcloud_auth/controller_extensions'
+

data/lib/soundcloud_auth/controller_extensions.rb

@@ -0,0 +1,72 @@
+module SoundcloudAuth
+  # These methods borrow HEAVILY from Rick Olsen's
+  # Restful Authentication. All cleverness props
+  # go to him, not me.
+  module ControllerExtensions
+    def self.included(base)
+      base.send :helper_method, :current_user, :logged_in?, :authorized?
+    end
+
+    protected
+
+    def authentication_failed(message, destination='/')
+      flash[:error] = message
+      redirect_to destination
+    end
+
+    def authentication_succeeded(message = 'You have logged in successfully.', destination = '/')
+      flash[:notice] = message
+      redirect_back_or_default destination
+    end
+
+    def current_user
+      @current_user ||= 
+        if session[:user_id]
+          User.find_by_id(session[:user_id])
+        elsif cookies[:remember_token]
+          User.from_remember_token(cookies[:remember_token])
+        else
+          false
+        end
+    end
+
+    def current_user=(new_user)
+      session[:user_id] = new_user.id
+      @current_user = new_user
+    end
+
+    def authorized?
+      !!current_user
+    end
+
+    def login_required
+      authorized? || access_denied 
+    end
+
+    def access_denied
+      store_location
+      redirect_to login_path
+    end
+
+    def store_location
+      session[:return_to] = request.request_uri
+    end
+
+    def redirect_back_or_default(default)
+      redirect_to(session[:return_to] || default)
+      session[:return_to] = nil
+    end
+
+    def logged_in?
+      !!current_user
+    end
+
+    def logout_keeping_session!
+      session[:user_id] = nil
+      @current_user = nil
+      cookies.delete(:remember_token)
+    end
+  end
+end
+
+ActionController::Base.send(:include, SoundcloudAuth::ControllerExtensions)

data/rails/init.rb

@@ -0,0 +1,7 @@
+# Gem Dependencies
+config.gem 'oauth'
+
+require 'json'
+require 'soundcloud_auth'
+
+RAILS_DEFAULT_LOGGER.info("** SoundcloudAuth initialized properly.")

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: soundcloud-auth
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Lee Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: oauth
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 0
+        - 3
+        - 1
+        version: 0.3.1
+  type: :runtime
+  version_requirements: *id001
+description: SoundcloudAuth is a Rails plugin gem that provides Single Sign-On capabilities for Rails applications via SoundCloud.
+email: lee@soundcloud.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- README.markdown
+- Rakefile
+- VERSION
+- app/controllers/sessions_controller.rb
+- app/models/soundcloud_auth/generic_user.rb
+- config/routes.rb
+- generators/soundcloud_auth/USAGE
+- generators/soundcloud_auth/soundcloud_auth_generator.rb
+- generators/soundcloud_auth/templates/migration.rb
+- generators/soundcloud_auth/templates/soundcloud_auth.yml
+- generators/soundcloud_auth/templates/user.rb
+- init.rb
+- lib/soundcloud_auth.rb
+- lib/soundcloud_auth/controller_extensions.rb
+- rails/init.rb
+has_rdoc: true
+homepage: http://github.com/leemartin/soundcloud-auth
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: SoundcloudAuth is a Rails plugin gem that provides Single Sign-On capabilities for Rails applications via SoundCloud.
+test_files: []
+