red_haze 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+config.yml
+tags
+.rvmrc

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in hypem.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/config.template.yml

@@ -0,0 +1,4 @@
+:client_id: CLIENT_ID
+:client_secret: CLIENT_SECRET
+:redirect_uri: http://myredirect.uri/
+

data/lib/red_haze/activity.rb

@@ -0,0 +1,5 @@
+module RedHaze
+  class Activity
+    include Helpers::Resource
+  end
+end

data/lib/red_haze/client.rb

@@ -0,0 +1,58 @@
+require "httparty"
+
+module RedHaze
+  class Client
+    include HTTParty
+    attr_accessor :client_id, :client_secret, :redirect_uri,
+                  :access_token, :expires_in, :refresh_token
+
+    TOKEN_ENDPOINT = "https://api.soundcloud.com/oauth2/token"
+    CONNECT_ENDPOINT = "https://soundcloud.com/connect"
+
+    def initialize(options={})
+      options_check(options)
+      update_from_response(options)
+    end
+
+    def authorize_url
+      raise "Missing redirect_uri" unless redirect_uri
+      params = "client_id=#{client_id}&redirect_uri=#{redirect_uri}&response_type=code"
+      URI.encode "#{CONNECT_ENDPOINT}?#{params}"
+    end
+
+    def get_token_from_code(code)
+      body =  { client_id:      client_id,
+                client_secret:  client_secret,
+                redirect_uri:   redirect_uri,
+                code:           code,
+                grant_type:     'authorization_code' }
+
+      response = self.class.post TOKEN_ENDPOINT, body: body,
+                  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
+
+      raise response.inspect unless response.code == 200
+      update_from_response(response)
+      self
+    end
+
+    private
+
+    def options_check(options)
+      keys = options.keys
+      unless (keys.include?(:client_id) && keys.include?(:client_secret)) ||
+              keys.include?(:access_token)
+        raise "missing client_id and client_secret, or access_token"
+      end
+    end
+
+    def update_from_response(response)
+      @client_id = response[:client_id]
+      @client_secret = response[:client_secret]
+      @redirect_uri = response[:redirect_uri]
+      @access_token = response[:access_token]
+      @expires_in = response[:expires_in]
+      @refresh_token = response[:refresh_token]
+    end
+
+  end
+end

data/lib/red_haze/collection.rb

@@ -0,0 +1,16 @@
+module RedHaze
+  class Collection
+    include Helpers::Resource
+    attr_reader :items, :next_href, :future_href
+    def initialize(arg)
+      @items = arg['collection'].collect { |r| Activity.new(r) }
+      @next_href = arg['next_href']
+      @future_href = arg['future_href']
+    end
+
+    def next
+      self.class.new Request.get(@next_href)
+    end
+
+  end
+end

data/lib/red_haze/comment.rb

@@ -0,0 +1,6 @@
+module RedHaze
+  class Comment
+    include Helpers::Resource
+
+  end
+end

data/lib/red_haze/group.rb

@@ -0,0 +1,28 @@
+module RedHaze
+  class Group
+    include Helpers::Resource
+
+    attr_reader :id
+
+    def members
+      get_endpoint("/members")
+    end
+
+    def moderators
+      get_endpoint("/moderators")
+    end
+
+    def contributors
+      get_endpoint("/contributors")
+    end
+
+    def contributors
+      get_endpoint("/contributors")
+    end
+
+    def users
+      get_endpoint("/users")
+    end
+
+  end
+end

data/lib/red_haze/helpers/resource.rb

@@ -0,0 +1,91 @@
+module RedHaze
+  module Helpers
+
+    module Resource
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      attr_reader :id
+
+      def initialize(arg)
+        case arg
+          when Fixnum then @id = arg
+          when Hash then initialize_from_hash(arg)
+          else raise "Not a valid Resource initialize arg: #{arg.inspect}"
+        end
+      end
+
+      def sync
+        initialize_from_hash Request.get(url)
+        self
+      end
+
+      def get_endpoint(endpoint, args={})
+        self.class.import_from_response Request.get(url + endpoint, args)
+      end
+
+      def put_endpoint(endpoint, args={})
+        default_args = {headers: {'Content-Length' => "0"}}
+        args.merge! default_args
+        Request.put(url + endpoint, args).parsed_response
+      end
+
+      def delete_endpoint(endpoint, args={})
+        Request.delete(url + endpoint, args).parsed_response
+      end
+
+      def url
+        class_name = self.class.name.downcase.split('::')[-1]
+        class_name == 'me' ? '/me' : "/#{class_name}s/#{id}"
+      end
+
+      private
+
+        def initialize_from_hash(arg)
+          arg.each_pair do |key, value|
+            case key
+              when 'created_at'
+                value = DateTime.parse(value)
+              when 'user', 'creator', 'track', 'origin'
+                value = self.class.instance_from_hash(value)
+              when 'tags'
+                value = value.split(',')
+            end
+            instance_variable_set "@#{key}", value
+            self.class.class_eval { attr_reader key }
+          end
+        end
+
+    module ClassMethods
+
+      def instance_from_hash(arg)
+        case
+          when arg['kind']
+            class_name = arg.delete('kind').capitalize
+            eval(class_name).new(arg)
+          when arg['type']
+            Activity.new arg
+          when arg['collection']
+            Collection.new arg
+          when arg.values.first['kind']
+            instance_from_hash arg.values.first
+          else
+            raise arg.inspect
+        end
+      end
+
+
+      def import_from_response(response)
+        if response.is_a? Array
+          response.collect { |i| instance_from_hash(i) }
+        elsif response.is_a? Hash
+          instance_from_hash response
+        end
+      end
+
+    end
+
+  end
+  end
+end

data/lib/red_haze/helpers.rb

@@ -0,0 +1,8 @@
+require_relative 'helpers/resource'
+
+module RedHaze
+  module Helpers
+
+    
+  end
+end

data/lib/red_haze/me.rb

@@ -0,0 +1,66 @@
+require 'red_haze/user'
+
+module RedHaze
+  class Me < User
+    FILTERS = [:all, :tracks_affiliated, :tracks_exclusive, :own]
+
+    def initialize
+      unless RedHaze.client.access_token
+        raise "You cannot access this object without a client access_token"
+      end
+      sync
+    end
+
+    def activities(args = {})
+      filter = args.delete(:filter) || :all
+      raise "Bad Activities filter: #{filter}" unless FILTERS.include?(filter)
+
+      filter = filter.to_s.sub('_','/')
+
+      get_endpoint("/activities/#{filter}", query: args)
+    end
+
+    def follow!(arg)
+      put_endpoint "/followings/#{item_id(arg)}"
+    end
+
+    def unfollow!(arg)
+      delete_endpoint "/followings/#{item_id(arg)}"
+    end
+
+    def follows?(arg)
+      existence_check "/me/followings", arg
+    end
+
+    def favorite!(arg)
+      put_endpoint "/favorites/#{item_id(arg)}"
+    end
+
+    def unfavorite!(arg)
+      delete_endpoint "/favorites/#{item_id(arg)}"
+    end
+
+    def favorite?(arg)
+      existence_check "/me/favorites", arg
+    end
+
+    private
+
+      def item_id(arg)
+        unless [RedHaze::User, RedHaze::Track, Fixnum].include?(arg.class)
+          raise ArgumentError 
+        end
+        arg.is_a?(Fixnum) ? arg : arg.id
+      end
+
+      # if the resource exists, we are redirected to a 404 page
+      # this will rescue on the first redirect and thus return true
+      def existence_check(path, arg)
+        response = Request.get "#{path}/#{item_id(arg)}", no_follow: true
+        response.code == 200
+      rescue HTTParty::RedirectionTooDeep
+        true
+      end
+
+  end
+end

data/lib/red_haze/playlist.rb

@@ -0,0 +1,6 @@
+module RedHaze
+  class Playlist
+    include Helpers::Resource
+
+  end
+end

data/lib/red_haze/request.rb

@@ -0,0 +1,22 @@
+require 'httparty'
+
+module RedHaze
+  class Request
+    include HTTParty
+    debug_output
+    headers 'Accept' => 'application/json'
+
+    def self.setup(client_id,access_token=nil)
+      params = {}
+      if access_token
+        base_uri 'https://api.soundcloud.com'
+        params[:oauth_token] = access_token
+      else
+        base_uri 'http://api.soundcloud.com'
+        params[:client_id] = client_id
+      end
+      default_params params
+    end
+
+  end
+end

data/lib/red_haze/track.rb

@@ -0,0 +1,23 @@
+module RedHaze
+  class Track
+    include Helpers::Resource
+
+    def favoriters
+      get_endpoint('/favoriters')
+    end
+
+    def comments
+      get_endpoint('/comments')
+    end
+
+    def shared_to
+      get_endpoint('/shared_to/users')
+    end
+
+    def owner
+      sync if user_id.nil?
+      User.new(user_id)
+    end
+
+  end
+end

data/lib/red_haze/user.rb

@@ -0,0 +1,35 @@
+module RedHaze
+  class User
+    include Helpers::Resource
+    
+    def followings(user_id=nil)
+      if user_id.nil?
+        get_endpoint('/followings')
+      else
+        response = get("/followings/#{user_id}")
+      end
+    end
+
+    def followers
+      get_endpoint('/followers')
+    end
+
+    def comments
+      get_endpoint('/comments')
+    end
+
+    def favorites
+      get_endpoint('/favorites')
+    end
+
+    def groups
+      get_endpoint('/groups')
+    end
+
+    def playlists
+      get_endpoint('/playlists')
+    end
+
+  end
+
+end

data/lib/red_haze/version.rb

@@ -0,0 +1,3 @@
+module RedHaze
+  VERSION = "0.0.1"
+end

data/lib/red_haze.rb

@@ -0,0 +1,28 @@
+require "red_haze/version"
+require 'red_haze/helpers'
+require "red_haze/client"
+require "red_haze/request"
+require "red_haze/playlist"
+require "red_haze/me"
+require "red_haze/user"
+require "red_haze/track"
+require "red_haze/comment"
+require "red_haze/group"
+require "red_haze/activity"
+require "red_haze/collection"
+
+module RedHaze
+  class << self
+    attr_accessor :client
+
+    def configure(options = {})
+      @client = Client.new(options)
+      Request.setup(@client.client_id, @client.access_token)
+      self
+    end
+
+    def configure_from_file(path)
+      configure YAML.load_file(path)
+    end
+  end
+end

data/red_haze.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "red_haze/version"
+
+Gem::Specification.new do |s|
+  s.name        = "red_haze"
+  s.version     = RedHaze::VERSION
+  s.authors     = ["Jack Anderson"]
+  s.email       = ["hi@janderson.me"]
+  s.homepage    = "https://github.com/JackCA/red_haze"
+  s.summary     = "a robust Ruby wrapper for the Soundcloud API"
+
+  s.rubyforge_project = "red_haze"
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9.2")
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "webmock"
+  s.add_development_dependency "vcr"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+  s.add_dependency 'httparty'
+  s.add_dependency 'multi_json'
+
+end